feat(archive): index v46 wire-evidence batch, free-threaded-only runtime, parse-failure recovery

.agent/handoffs/external-agent-campaigns/2026-07-16-gpt-pro-wave/testdiet/context/testsuite_diet/04-harness-architecture.md

@@ -142,9 +142,7 @@ expressions (or a typed AST produced by the production parser) and keep only
 the independent planted-fact oracle. A test should look conceptually like:
 
 ```python
-expected = corpus.facts.session_ids_matching(
-    origin="codex-session", text_token="needle", min_messages=7
-)
+expected = corpus.facts.session_ids_matching(origin="codex-session", text_token="needle", min_messages=7)
 assert await run_repository_query(expression) == expected
 assert run_cli_query(expression).session_ids == expected
 assert await run_http_query(expression) == expected

.agent/handoffs/external-agent-campaigns/2026-07-17-gpt-pro-wave-2/results/ann-01/r01/extracted/HANDOFF.md

@@ -133,7 +133,7 @@ from polylogue.annotations.importer import AnnotationBatchImportRequest
 request = AnnotationBatchImportRequest(
     jsonl=jsonl_text,
     batch_id="stable-run-id",
-    schema_id="seed.activity",          # or an operator-promoted archive-local id
+    schema_id="seed.activity",  # or an operator-promoted archive-local id
     schema_version=1,
     target_ref="session:...",
     source_result_ref="result-set:...",

.agent/handoffs/external-agent-campaigns/2026-07-17-gpt-pro-wave-2/results/misc-02/r01/extracted/HANDOFF.md

@@ -376,8 +376,7 @@ try:
     recipe_hash_sql = f"X'{recipe.recipe_hash.hex()}'"
     output_hash_sql = f"X'{recipe.output_contract_hash.hex()}'"
     desired_key_sql = (
-        "polylogue_embedding_derivation_key("
-        f"s.session_id, ds.source_hash, {recipe_hash_sql}, {output_hash_sql})"
+        f"polylogue_embedding_derivation_key(s.session_id, ds.source_hash, {recipe_hash_sql}, {output_hash_sql})"
     )
     key_current = f"""(
         d.session_id IS NOT NULL
@@ -452,9 +451,7 @@ try:
     assert row is not None
     result = {name: int(value or 0) for name, value in zip(columns, row, strict=True)}
     result["partition_check"] = (
-        result["exact_fresh_sessions"]
-        + result["exact_pending_sessions"]
-        + result["exact_blocked_sessions"]
+        result["exact_fresh_sessions"] + result["exact_pending_sessions"] + result["exact_blocked_sessions"]
         == result["eligible_sessions"]
     )
     print(json.dumps(result, indent=2, sort_keys=True))

.agent/handoffs/polylogue-deep-research-2026-07-09/01-cache-pricing-policy.md

@@ -90,7 +90,7 @@ read. This is correct, not a gap.
 ### How the loader ingests this (`pricing.py:_load_litellm_catalog`)
 
 ```python
-cache_read_usd_per_1m  = float(entry.get("cache_read_input_token_cost") or 0.0)     * 1_000_000
+cache_read_usd_per_1m = float(entry.get("cache_read_input_token_cost") or 0.0) * 1_000_000
 cache_write_usd_per_1m = float(entry.get("cache_creation_input_token_cost") or 0.0) * 1_000_000
 ```
 

.agent/handoffs/polylogue-deep-research-2026-07-09/06-atropos-export.md

@@ -32,12 +32,12 @@ one prompt with N candidate rollouts; the JSONL writer emits one group per line)
 
 ```python
 class ScoredDataGroup(TypedDict):
-    tokens: List[List[int]]                                  # per-member token ids
-    masks: List[List[int]]                                   # per-member loss mask (-100 / token-id convention)
-    scores: List[float]                                      # per-member scalar reward
-    advantages: Optional[List[List[float]]]                 # per-token advantages
+    tokens: List[List[int]]  # per-member token ids
+    masks: List[List[int]]  # per-member loss mask (-100 / token-id convention)
+    scores: List[float]  # per-member scalar reward
+    advantages: Optional[List[List[float]]]  # per-token advantages
     ref_logprobs: Optional[List[List[float]]]
-    messages: Optional[List[List[Message]]]                 # per-member OpenAI-style message list
+    messages: Optional[List[List[Message]]]  # per-member OpenAI-style message list
     generation_params: Optional[Dict[str, Any]]
     inference_logprobs: Optional[List[List[float]]]
     group_overrides: Optional[Dict]
@@ -52,11 +52,13 @@ Supporting types (`atroposlib/type_definitions.py`):
 ```python
 number = int | float
 
+
 class Message(TypedDict):
     role: Literal["system", "user", "assistant", "tool"]
-    content: Content                  # str (or multimodal content blocks)
+    content: Content  # str (or multimodal content blocks)
     reward: Optional[float]
 
+
 Item = Any
 ```
 
@@ -73,8 +75,7 @@ Key structural facts:
   `messages is None`, `base.py` auto-fills it by decoding `tokens`:
   ```python
   group["messages"] = [
-      [{"role": "user", "content": self.tokenizer.decode(group["tokens"][i])}]
-      for i in range(len(group["tokens"]))
+      [{"role": "user", "content": self.tokenizer.decode(group["tokens"][i])}] for i in range(len(group["tokens"]))
   ]
   ```
   i.e. messages can be supplied directly and Atropos will *not* overwrite them.

.agent/handoffs/polylogue-deep-research-2026-07-09/07-reprice-in-place-perf.md

@@ -112,16 +112,19 @@ once and issue a handful of **set-based** UPDATEs (each covering all rows for on
 model), never row-by-row.
 
 ```python
-def reprice_in_place(conn):                      # one sqlite3 connection
-    seed_price_catalog(conn)                     # idempotent: ensure new catalog_id rows exist
-    catalog_id = _catalog_id()                   # new f"{PROVENANCE}-{EFFECTIVE_DATE}"
+def reprice_in_place(conn):  # one sqlite3 connection
+    seed_price_catalog(conn)  # idempotent: ensure new catalog_id rows exist
+    catalog_id = _catalog_id()  # new f"{PROVENANCE}-{EFFECTIVE_DATE}"
     now_ms = int(time.time() * 1000)
 
-    models = [r[0] for r in conn.execute(
-        "SELECT DISTINCT model_name FROM session_model_usage "
-        "WHERE cost_provenance IN ('priced','estimated')")]
+    models = [
+        r[0]
+        for r in conn.execute(
+            "SELECT DISTINCT model_name FROM session_model_usage WHERE cost_provenance IN ('priced','estimated')"
+        )
+    ]
 
-    with conn:                                   # ATOMIC: single transaction
+    with conn:  # ATOMIC: single transaction
         for raw in models:
             norm = _normalize_model(raw)
             p = PRICING.get(norm)
@@ -130,7 +133,8 @@ def reprice_in_place(conn):                      # one sqlite3 connection
                 conn.execute(
                     "UPDATE session_model_usage SET cost_usd=NULL, priced_with=NULL, "
                     "priced_at_ms=NULL WHERE model_name=? AND cost_provenance IN ('priced','estimated')",
-                    (raw,))
+                    (raw,),
+                )
                 continue
             ir, orr = p.input_usd_per_1m, p.output_usd_per_1m
             crr, cwr = p.cache_read_usd_per_1m, p.cache_write_usd_per_1m
@@ -145,7 +149,8 @@ def reprice_in_place(conn):                      # one sqlite3 connection
                   AND cost_provenance IN ('priced','estimated')
                   AND (input_tokens+output_tokens+cache_read_tokens+cache_write_tokens) > 0
                 """,
-                (ir, orr, crr, cwr, catalog_id, now_ms, raw))
+                (ir, orr, crr, cwr, catalog_id, now_ms, raw),
+            )
 
         # re-aggregate session_profiles from the refreshed per-model rows
         conn.execute(
@@ -161,7 +166,8 @@ def reprice_in_place(conn):                      # one sqlite3 connection
             WHERE sp.session_id = agg.session_id
               AND sp.cost_provenance IN ('priced','estimated','mixed')
             """,
-            (catalog_id, now_ms))
+            (catalog_id, now_ms),
+        )
 ```
 
 Notes:

.agent/handoffs/polylogue-gpt-pro-2026-07-06/B-A16-measure-registry.md

@@ -51,16 +51,16 @@ class MeasureSpec(BaseModel):
     id: str
     construct: str
     operationalization: str
-    reducer: Literal["count","sum","ratio","mean","median","pXX","entropy","Gini","zstd-ratio"]
+    reducer: Literal["count", "sum", "ratio", "mean", "median", "pXX", "entropy", "Gini", "zstd-ratio"]
     column_expr: str
-    unit_frame: Literal["sessions","actions","messages","observed-events","work-events","phases","threads"]
+    unit_frame: Literal["sessions", "actions", "messages", "observed-events", "work-events", "phases", "threads"]
     denominator_expr: str | None
-    evidence_tier: Literal["structural","provider-reported","derived","heuristic","mixed"]
+    evidence_tier: Literal["structural", "provider-reported", "derived", "heuristic", "mixed"]
     required_coverage: CoverageGate
     confounds: tuple[str, ...]
     provenance_mixing_flags: tuple[str, ...]
     uncertainty: UncertaintySpec
-    null_policy: Literal["suppress","zero","exclude","separate-unknown"]
+    null_policy: Literal["suppress", "zero", "exclude", "separate-unknown"]
     formula_version: int
     output_schema: str
     footnote_template: str
@@ -187,7 +187,7 @@ MeasureSpec(
     evidence_tier="structural",
     required_coverage={"session_latency_profiles": "present", "timing_provenance": "timestamped_or_structural"},
     uncertainty={"kind": "proportion", "interval": "wilson"},
-    footnote_template="n={n}, coverage={coverage}, timing_provenance={timing_provenance}"
+    footnote_template="n={n}, coverage={coverage}, timing_provenance={timing_provenance}",
 )
 ```
 

.agent/handoffs/polylogue-gpt-pro-2026-07-06/B-A17-query-objects.md

@@ -372,8 +372,7 @@ def assertion_id_for_finding(
     value: object,
     evidence_refs: Sequence[str],
     detector_ref: str,
-) -> str:
-    ...
+) -> str: ...
 ```
 
 [proposal] Add:
@@ -384,8 +383,7 @@ def upsert_findings_as_assertions(
     findings: Sequence[FindingCandidate],
     *,
     now_ms: int | None = None,
-) -> list[ArchiveAssertionEnvelope]:
-    ...
+) -> list[ArchiveAssertionEnvelope]: ...
 ```
 
 Use the pathology pattern exactly:

.agent/handoffs/polylogue-gpt-pro-2026-07-06/bundles/rnd-bundle-2-of-6.md

@@ -1082,36 +1082,55 @@ polylogue/analytics/measures.py    # MeasureSpec, MEASURE_REGISTRY, evaluate_mea
 `MeasureSpec` is a frozen pydantic/dataclass declared in code exactly like `InsightType` and `RigorContract` — the registry is a `dict[str, MeasureSpec]`, not a table.
 
 ```python
-class EvidenceTier(str, Enum):        # ordered weakest→strongest for footnote precedence
-    HEURISTIC = "heuristic"; DERIVED = "derived"
-    PROVIDER_REPORTED = "provider_reported"; STRUCTURAL = "structural"
+class EvidenceTier(str, Enum):  # ordered weakest→strongest for footnote precedence
+    HEURISTIC = "heuristic"
+    DERIVED = "derived"
+    PROVIDER_REPORTED = "provider_reported"
+    STRUCTURAL = "structural"
+
+
+class SampleFrame(str, Enum):  # RISK-3 keystone
+    LOGICAL_SESSION = "logical_session"  # default: dedup lineage via session_links
+    PHYSICAL_SESSION = "physical_session"
+    ACTION = "action"
+    MESSAGE = "message"
+    USAGE_EVENT = "usage_event"
 
-class SampleFrame(str, Enum):         # RISK-3 keystone
-    LOGICAL_SESSION = "logical_session"   # default: dedup lineage via session_links
-    PHYSICAL_SESSION = "physical_session"; ACTION = "action"; MESSAGE = "message"; USAGE_EVENT = "usage_event"
 
 class Reducer(str, Enum):
-    COUNT; SUM; MEAN; MEDIAN; QUANTILE; PROPORTION; RATIO; ENTROPY; DISTINCT
+    COUNT
+    SUM
+    MEAN
+    MEDIAN
+    QUANTILE
+    PROPORTION
+    RATIO
+    ENTROPY
+    DISTINCT
+
 
 class UncertaintyMethod(str, Enum):
-    NONE; WILSON; BOOTSTRAP        # WILSON⇒proportions, BOOTSTRAP⇒mean/median/quantile/ratio
+    NONE
+    WILSON
+    BOOTSTRAP  # WILSON⇒proportions, BOOTSTRAP⇒mean/median/quantile/ratio
+
 
 @dataclass(frozen=True, slots=True)
 class MeasureSpec:
     name: str
-    construct: str                       # what it operationalizes (prose)
-    unit_label: str                      # display unit ("ratio","tokens","$/session","bits","1/hr")
-    unit_frame: SampleFrame              # which rows the reducer folds
+    construct: str  # what it operationalizes (prose)
+    unit_label: str  # display unit ("ratio","tokens","$/session","bits","1/hr")
+    unit_frame: SampleFrame  # which rows the reducer folds
     reducer: Reducer
-    numerator_expr: str                  # SQL/column expr over the frame (the "formula ref")
-    denominator_expr: str | None         # EXPLICIT denominator for RATIO/PROPORTION (never implicit)
+    numerator_expr: str  # SQL/column expr over the frame (the "formula ref")
+    denominator_expr: str | None  # EXPLICIT denominator for RATIO/PROPORTION (never implicit)
     quantile: float | None = None
-    default_group_fields: tuple[str, ...] = ()   # ⊆ descriptor.aggregate_group_fields + windows
+    default_group_fields: tuple[str, ...] = ()  # ⊆ descriptor.aggregate_group_fields + windows
     evidence_tier: EvidenceTier
-    required_coverage: tuple[CoveragePredicate, ...] = ()   # checked at composition (§2.B)
-    confounds: tuple[str, ...]           # non-empty is an audit invariant
+    required_coverage: tuple[CoveragePredicate, ...] = ()  # checked at composition (§2.B)
+    confounds: tuple[str, ...]  # non-empty is an audit invariant
     uncertainty: UncertaintyMethod
-    output_schema: str                   # payload model name for render/openapi
+    output_schema: str  # payload model name for render/openapi
 ```
 
 **Optional (deferred, not v1):** a *rebuildable* `measure_snapshot` cache table in index.db (schema v25) keyed `(measure, group_key, window)` for scale, dropped-and-recomputed on any index rebuild. Spec it only when §4 scale numbers demand it; keep v1 compute-on-read.