traceforge space

BUILD.json

@@ -1,6 +1,6 @@
 {
-  "built_at": "2026-10-27T13:19:56",
-  "commit": "b412454",
+  "built_at": "2026-10-27T17:07:51",
+  "commit": "173cb13",
   "files": 49,
   "with_store": false,
   "with_card": true

data/dataset/dataset_card.json

@@ -1,7 +1,7 @@
 {
-  "traces": 3875,
+  "traces": 3924,
   "languages": {
-    "en": 3720,
+    "en": 3769,
     "de": 155
   },
   "language_pct": {
@@ -15,34 +15,34 @@
     ],
     "rows": {
       "review": {
-        "en": 1177,
+        "en": 1202,
         "de": 63,
-        "total": 1240
+        "total": 1265
       },
       "implement": {
-        "en": 647,
+        "en": 657,
         "de": 39,
-        "total": 686
+        "total": 696
       },
       "debug": {
-        "en": 630,
+        "en": 634,
         "de": 22,
-        "total": 652
+        "total": 656
       },
       "research": {
-        "en": 516,
+        "en": 521,
         "de": 6,
-        "total": 522
+        "total": 527
       },
       "other": {
-        "en": 282,
+        "en": 283,
         "de": 4,
-        "total": 286
+        "total": 287
       },
       "test": {
-        "en": 147,
+        "en": 149,
         "de": 11,
-        "total": 158
+        "total": 160
       },
       "ops": {
         "en": 105,
@@ -55,9 +55,9 @@
         "total": 87
       },
       "refactor": {
-        "en": 74,
+        "en": 76,
         "de": 3,
-        "total": 77
+        "total": 79
       },
       "creative": {
         "en": 49,
@@ -71,31 +71,31 @@
       }
     },
     "totals": {
-      "en": 3720,
+      "en": 3769,
       "de": 155,
-      "total": 3875
+      "total": 3924
     }
   },
   "tools_and_prompt": {
     "tools": {
-      "rows": 3875,
-      "with_tools": 3874,
+      "rows": 3924,
+      "with_tools": 3923,
       "pct": 100.0,
       "by_source": {
-        "derived-from-observed-calls": 3469,
-        "claude-request-shape": 405,
+        "derived-from-observed-calls": 3509,
+        "claude-request-shape": 414,
         "none": 1
       }
     },
     "system_prompt": {
-      "rows": 3875,
-      "with_system": 1716,
-      "pct": 44.3,
+      "rows": 3924,
+      "with_system": 1726,
+      "pct": 44.0,
       "by_source": {
-        "none": 2159,
+        "none": 2198,
         "raw-system-row": 663,
-        "claude-request-shape": 405,
-        "codex-base-instructions": 354,
+        "claude-request-shape": 414,
+        "codex-base-instructions": 355,
         "in-trace": 292,
         "hermes-system-prompts": 2
       }
@@ -104,8 +104,8 @@
   "provenance": {
     "basis": "session-id prefix (the improver overwrites meta.source)",
     "counts": {
-      "real-session": 1720,
-      "subagent": 691,
+      "real-session": 1723,
+      "subagent": 737,
       "nemotron-agentic-ka": 581,
       "split-segment": 509,
       "nemotron-agentic-tc": 370,
@@ -115,11 +115,11 @@
       "nemotron-swe-e8ff278b": 1
     },
     "pct": {
-      "real-session": 44.4,
-      "subagent": 17.8,
-      "nemotron-agentic-ka": 15.0,
-      "split-segment": 13.1,
-      "nemotron-agentic-tc": 9.5,
+      "real-session": 43.9,
+      "subagent": 18.8,
+      "nemotron-agentic-ka": 14.8,
+      "split-segment": 13.0,
+      "nemotron-agentic-tc": 9.4,
       "nemotron-swe-3c63eaaa": 0.0,
       "nemotron-swe-6ca796dd": 0.0,
       "nemotron-swe-bc9ee6b7": 0.0,
@@ -127,58 +127,58 @@
     }
   },
   "agent_roles": {
-    "orchestrator": 3184,
-    "subagent": 691
+    "orchestrator": 3187,
+    "subagent": 737
   },
   "tasks": {
-    "review": 1240,
-    "implement": 686,
-    "debug": 652,
-    "research": 522,
-    "other": 286,
-    "test": 158,
+    "review": 1265,
+    "implement": 696,
+    "debug": 656,
+    "research": 527,
+    "other": 287,
+    "test": 160,
     "ops": 107,
     "data-analysis": 87,
-    "refactor": 77,
+    "refactor": 79,
     "creative": 49,
     "office-docs": 11
   },
   "messages": {
-    "total": 127999,
+    "total": 130671,
     "by_role": {
-      "system": 1716,
-      "user": 4294,
-      "assistant": 62022,
-      "tool": 59967
+      "system": 1726,
+      "user": 4345,
+      "assistant": 63391,
+      "tool": 61209
     },
     "per_trace": {
-      "mean": 33.0,
-      "median": 22,
-      "p90": 70,
+      "mean": 33.3,
+      "median": 22.0,
+      "p90": 71,
       "max": 252
     }
   },
   "tool_calls": {
-    "total": 59967,
+    "total": 61209,
     "per_trace": {
-      "mean": 15.5,
-      "median": 10,
-      "p90": 33,
+      "mean": 15.6,
+      "median": 10.0,
+      "p90": 34,
       "max": 125
     },
     "traces_with_none": 1,
     "distinct_tools": 553,
     "top_tools": {
-      "Bash": 22114,
-      "exec": 11489,
+      "Bash": 22977,
+      "exec": 11517,
       "terminal": 3660,
       "read_file": 2835,
-      "Read": 2551,
-      "Edit": 2053,
+      "Read": 2673,
+      "Edit": 2210,
       "search_files": 1716,
       "execute_code": 1581,
       "tool_call": 1511,
-      "Grep": 914,
+      "Grep": 939,
       "skill_view": 861,
       "patch": 738,
       "unlock_discoverable_agent_tool": 457,
@@ -189,43 +189,43 @@
   "user_turns": {
     "per_trace": {
       "mean": 1.1,
-      "median": 1,
+      "median": 1.0,
       "p90": 1,
       "max": 18
     },
-    "single_turn_traces": 3570,
-    "multi_turn_traces": 305
+    "single_turn_traces": 3617,
+    "multi_turn_traces": 307
   },
   "tokens": {
     "method": "chars/4 (prose proxy); scale by ~1.15 for a central estimate",
     "budget": 131072,
-    "chars_total": 313006272,
-    "est_total": 78251568,
+    "chars_total": 318237136,
+    "est_total": 79559284,
     "per_trace": {
-      "mean": 20193.6,
-      "median": 16324,
-      "p90": 46390,
+      "mean": 20274.7,
+      "median": 16510.5,
+      "p90": 46090,
       "max": 121769
     },
     "fits_budget": {
       "4096": {
         "traces": 1026,
-        "pct": 26.5
+        "pct": 26.1
       },
       "8192": {
         "traces": 1264,
-        "pct": 32.6
+        "pct": 32.2
       },
       "16384": {
-        "traces": 1944,
-        "pct": 50.2
+        "traces": 1950,
+        "pct": 49.7
       },
       "65536": {
-        "traces": 3826,
-        "pct": 98.7
+        "traces": 3875,
+        "pct": 98.8
       },
       "131072": {
-        "traces": 3875,
+        "traces": 3924,
         "pct": 100.0
       }
     }
@@ -234,10 +234,10 @@
   "supervision": {
     "contract": "loss on assistant spans only; tool/user/system spans are masked context",
     "chars_by_role": {
-      "system": 12352139,
-      "user": 5725036,
-      "assistant": 11998958,
-      "tool": 282930139
+      "system": 12435083,
+      "user": 5887077,
+      "assistant": 12168420,
+      "tool": 287746556
     },
     "assistant_share_pct": 3.8,
     "tool_share_pct": 90.4
@@ -248,54 +248,54 @@
       "D1": {
         "label": "one-shot / single edit",
         "traces": 111,
-        "pct": 2.9
+        "pct": 2.8
       },
       "D2": {
         "label": "short loop",
         "traces": 680,
-        "pct": 17.5
+        "pct": 17.3
       },
       "D3": {
         "label": "multi-step",
-        "traces": 1246,
-        "pct": 32.2
+        "traces": 1253,
+        "pct": 31.9
       },
       "D4": {
         "label": "long session",
-        "traces": 840,
-        "pct": 21.7
+        "traces": 857,
+        "pct": 21.8
       },
       "D5": {
         "label": "very long session",
-        "traces": 998,
-        "pct": 25.8
+        "traces": 1023,
+        "pct": 26.1
       }
     },
     "tool_calls": {
-      "mean": 15.5,
-      "median": 10,
-      "p90": 33,
+      "mean": 15.6,
+      "median": 10.0,
+      "p90": 34,
       "max": 125
     },
     "messages": {
-      "mean": 33.0,
-      "median": 22,
-      "p90": 70,
+      "mean": 33.3,
+      "median": 22.0,
+      "p90": 71,
       "max": 252
     },
     "est_tokens": {
-      "mean": 20193.6,
-      "median": 16324,
-      "p90": 46390,
+      "mean": 20274.7,
+      "median": 16510.5,
+      "p90": 46090,
       "max": 121769
     }
   },
   "safety_filter": {
     "applied": true,
-    "traces_in": 4103,
-    "traces_kept": 3875,
-    "traces_excluded": 228,
-    "excluded_secret": 204,
+    "traces_in": 4155,
+    "traces_kept": 3924,
+    "traces_excluded": 231,
+    "excluded_secret": 207,
     "excluded_personal": 24,
     "rule": "drop any trace carrying credential material (passwords, tokens, private keys, connection strings with real credentials) or third-party personal data (private legal correspondence, home addresses, phone numbers, IBANs). Code, internal hostnames, business contact addresses and the owner's own identity stay.",
     "report": "safety_report.json"
@@ -304,7 +304,7 @@
     "classes": {
       "time_sensitive": 13,
       "time_anchored": 12,
-      "not_time_sensitive": 3850
+      "not_time_sensitive": 3899
     },
     "labels": {
       "time_sensitive": "answer decays: temporal fact, no retrieval tool",

scratch/unify_space3/meta.json

@@ -0,0 +1,4 @@
+{
+  "version": 1,
+  "created_at": 1793117281.461422
+}

traceforge/cli.py

@@ -449,37 +449,46 @@ def _improve_one(cfg, r, sid, max_attempts, skip_existing, prog, liv=None):
 
     try:
         if cfg.splice:
-            # windowed direct-HTTP engine (no agent runtime)
+            # The SAME pipeline the Gradio app runs. One implementation, so
+            # a gate, a no-op rule or a measurement can never drift between
+            # the batch and the Space again.
             from traceforge.improver import ImproverResult
-            from traceforge.splice import improve_trace_splice
+            from traceforge.space.pipeline import process_trace
 
-            sres = improve_trace_splice(
-                cfg, t, status_cb=cb, max_attempts=max_attempts,
-            )
+            pres = process_trace(cfg, t, max_attempts=max_attempts,
+                                 seed=t, label_task=False,
+                                 reset_workdir=False, status_cb=cb)
             res = ImproverResult(
-                session_id=sid, ok=sres["ok"], improved=sres["improved"],
-                reply=sres.get("route", ""), errors=sres["errors"],
-                attempts=sres["attempts"],
-                duration_s=sres["duration_s"],
+                session_id=sid, ok=pres.ok, improved=pres.improved,
+                reply=pres.route, errors=pres.errors,
+                attempts=pres.attempts, duration_s=pres.duration_s,
             )
-            if res.ok and res.improved is not None \
-                    and sres.get("route") != "regate":
+            if res.ok and res.improved is not None:
                 out = os.path.join(cfg.improved_dir, f"{sid}.json")
                 res.improved.save(out)
-                prog.write(
-                    f"IMPROVED {sid} ({res.attempts} attempts, "
-                    f"{res.duration_s:.0f}s, {res.reply})"
-                )
-            elif res.ok:
-                prog.write(
-                    f"IMPROVED {sid} (regate, {res.duration_s:.0f}s)"
-                )
+                note = (" · no change (the raw trace already reads as ideal)"
+                        if pres.no_change else "")
+                if pres.route == "regate":
+                    prog.write(f"IMPROVED {sid} (regate, "
+                               f"{res.duration_s:.0f}s){note}")
+                else:
+                    prog.write(
+                        f"IMPROVED {sid} ({res.attempts} attempts, "
+                        f"{res.duration_s:.0f}s, {res.reply}){note}"
+                    )
             else:
                 prog.write(f"FAILED   {sid}: {res.errors}")
-            _write_manifest_row(cfg, res.to_dict())
+            row = res.to_dict()
+            row["route"] = pres.route
+            row["no_change"] = pres.no_change
+            row["time_sensitivity"] = pres.time_sensitivity
+            _write_manifest_row(cfg, row)
             if liv is not None:
                 liv.registry.end(sid)
             return sid, res
+        # Legacy agent engine (`splice: false`). It is not the pipeline the
+        # Space runs, so it keeps its own behaviour; the batch only reaches
+        # it when the config explicitly turns the splice engine off.
         res = improve_trace(
             cfg, t, max_attempts=max_attempts, status_cb=cb
         )

traceforge/defects.py

@@ -116,7 +116,8 @@ _RULES: list[tuple[str, re.Pattern[str]]] = [
     ("D-TASK-05", re.compile(r"harness dispatch brief|dispatch brief", re.I)),
     ("D-TASK-04", re.compile(r"no user task message|no user task", re.I)),
     ("D-TASK-02", re.compile(r"reframe", re.I)),
-    ("D-VER-02", re.compile(r"fabricated tool result|shares no content", re.I)),
+    ("D-VER-02", re.compile(r"fabricated tool result|shares no content"
+                            r"|self-grounding", re.I)),
     ("D-FMT-01", re.compile(r"multi-turn:.*dropped|pairing|orphan", re.I)),
     ("D-FMT-03", re.compile(r"final_blob|final answer is a (?:file )?dump", re.I)),
     ("D-FMT-04", re.compile(r"self_talk|self-talk", re.I)),

traceforge/space/__init__.py

@@ -9,13 +9,15 @@ from traceforge.space.hashing import (canonical_messages, fingerprint,
                                       output_hash, seed_hash, short_hash,
                                       tool_names)
 from traceforge.space.ingest import parse_records, read_upload, trace_from_record
-from traceforge.space.pipeline import (SpacePipeline, pipeline_ready,
+from traceforge.space.pipeline import (ProcessResult, SpacePipeline,
+                                       pipeline_ready, process_trace,
                                        space_config)
 from traceforge.space.store import (DONE, FAILED, QUEUED, REJECTED, RUNNING,
                                     TraceStore)
 
 __all__ = [
     "TraceStore", "SpacePipeline", "space_config", "pipeline_ready",
+    "process_trace", "ProcessResult",
     "seed_hash", "output_hash", "short_hash", "fingerprint",
     "canonical_messages", "tool_names", "trace_from_record",
     "parse_records", "read_upload",

traceforge/space/pipeline.py

@@ -27,6 +27,7 @@ import json
 import os
 import shutil
 import time
+from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from traceforge.config import Config, repo_root_from_pkg
@@ -126,16 +127,139 @@ def pipeline_ready(cfg: Config) -> tuple[bool, str]:
     return True, f"{model} @ {base}"
 
 
-def _same_conversation(record: dict, improved: Trace) -> bool:
-    """True when the rewrite is the seed, message for message."""
+def _same_conversation(record: Any, improved: Trace) -> bool:
+    """True when the rewrite is the seed, message for message.
+
+    ``record`` may be the submitted dict or the raw ``Trace`` — the batch
+    passes the trace it loaded, the Space passes the stored seed.
+    """
     try:
         from traceforge.space.hashing import canonical_messages
-        return (canonical_messages(record) ==
+        seed = record.to_dict() if isinstance(record, Trace) else record
+        return (canonical_messages(seed) ==
                 canonical_messages(improved.to_dict()))
     except Exception:
         return False
 
 
+# ------------------------------------------------------- the one pipeline
+
+@dataclass
+class ProcessResult:
+    """What one trace produced. The only shape a caller has to understand."""
+
+    ok: bool
+    improved: Optional[Trace] = None
+    route: str = ""
+    attempts: int = 0
+    duration_s: float = 0.0
+    errors: list[str] = field(default_factory=list)
+    no_change: bool = False
+    task: str = ""
+    time_sensitivity: dict = field(default_factory=dict)
+    time_sensitivity_improved: dict = field(default_factory=dict)
+
+
+def _time_sensitivity(obj: Any) -> dict:
+    try:
+        from traceforge.timesensitivity import detect
+        d = detect(obj)
+        return {k: d[k] for k in ("class", "label", "temporal_facts",
+                                  "retrieval_available", "retrieval_called",
+                                  "needs_rewrite", "score")}
+    except Exception as e:
+        return {"class": "", "label": f"unavailable: {e}"}
+
+
+def process_trace(cfg: Config, trace: Trace, *, max_attempts: int = 2,
+                  seed: Any = None, reset_workdir: bool = False,
+                  label_task: bool = True,
+                  status_cb: Any = None) -> ProcessResult:
+    """THE pipeline: one trace in, one ideal trace out (or a reason).
+
+    Both the Gradio app (``SpacePipeline.process``) and the local batch
+    (``cli._improve_one``) call this, so the rewrite, the gates, the no-op
+    check and the time-sensitivity measurement exist once.
+
+    ``seed`` is the submitted record when the caller has one (the Space
+    does, and it may carry a ``tools`` array the Trace lost); the raw
+    ``trace`` is used otherwise.  ``reset_workdir`` is True for the Space,
+    where a re-queued seed must not regate a stale artifact, and False for
+    the batch, where the workdir cache is the resume mechanism.
+    """
+    started = time.time()
+    sid = trace.session_id
+    if reset_workdir:
+        shutil.rmtree(os.path.join(cfg.improver_workdir, sid),
+                      ignore_errors=True)
+
+    try:
+        from traceforge.splice import improve_trace_splice
+        raw = improve_trace_splice(cfg, trace, max_attempts=max_attempts,
+                                   status_cb=status_cb)
+        res = {"ok": raw.get("ok"), "improved": raw.get("improved"),
+               "errors": list(raw.get("errors") or []),
+               "route": raw.get("route") or "",
+               "attempts": raw.get("attempts") or 0,
+               "duration_s": raw.get("duration_s") or 0.0}
+    except Exception as e:
+        return ProcessResult(ok=False, errors=[f"pipeline crashed: {e}"],
+                             duration_s=time.time() - started)
+
+    if not res.get("ok") or res.get("improved") is None:
+        return ProcessResult(
+            ok=False, errors=list(res.get("errors") or ["no output"]),
+            route=res.get("route") or "", attempts=res.get("attempts") or 0,
+            duration_s=time.time() - started)
+
+    improved: Trace = res["improved"]
+
+    # The splice engine gates before returning; re-checking here makes the
+    # pipeline's own contract explicit and catches a regate path that
+    # bypassed the engine's gate chain.
+    try:
+        from traceforge.validate import validate_structural
+        errs = validate_structural(improved)
+    except Exception as e:
+        errs = [f"validator crashed: {e}"]
+    if not errs:
+        # The ideal must carry its own evidence: a rewrite that drops the
+        # tool result but keeps the claim passes source-grounding yet
+        # teaches the model to assert facts it never saw.
+        try:
+            from traceforge.grounding import self_grounding_errors
+            errs = self_grounding_errors(improved)
+        except Exception as e:
+            errs = [f"self-grounding check crashed: {e}"]
+    if errs:
+        return ProcessResult(
+            ok=False, errors=errs, route=res.get("route") or "",
+            attempts=res.get("attempts") or 0,
+            duration_s=time.time() - started)
+
+    # Task bucket: heuristic only — neither caller should spend an LLM call
+    # on a label the dashboard can derive for free. The batch turns this off
+    # because `traceforge classify` writes the authoritative LLM label and
+    # the benchmark prefers `trace.task` when it is set.
+    if label_task:
+        try:
+            from traceforge.classify import classify_heuristic
+            improved.task = classify_heuristic(improved).get("task") or ""
+        except Exception:
+            pass
+
+    seed_obj = seed if seed is not None else trace
+    return ProcessResult(
+        ok=True, improved=improved,
+        route=res.get("route") or "", attempts=res.get("attempts") or 0,
+        duration_s=time.time() - started,
+        no_change=_same_conversation(seed_obj, improved),
+        task=improved.task or "",
+        time_sensitivity=_time_sensitivity(seed_obj),
+        time_sensitivity_improved=_time_sensitivity(improved),
+    )
+
+
 # ----------------------------------------------------------------- pipeline
 
 class SpacePipeline:
@@ -203,62 +327,18 @@ class SpacePipeline:
 
         # A fresh attempt must not regate a stale artifact from a previous
         # run (the splice engine's stage-0 fast path would promote it as-is).
-        workdir = os.path.join(self.cfg.improver_workdir, sid)
-        shutil.rmtree(workdir, ignore_errors=True)
+        res = process_trace(self.cfg, trace, max_attempts=self.max_attempts,
+                            seed=record, reset_workdir=True)
+        if not res.ok or res.improved is None:
+            return self._fail(h, res.errors, started, route=res.route,
+                              attempts=res.attempts)
 
-        try:
-            from traceforge.splice import improve_trace_splice
-            res = improve_trace_splice(
-                self.cfg, trace, max_attempts=self.max_attempts,
-            )
-        except Exception as e:
-            return self._fail(h, [f"pipeline crashed: {e}"], started)
-
-        if not res.get("ok") or res.get("improved") is None:
-            return self._fail(h, list(res.get("errors") or ["no output"]),
-                              started, route=res.get("route"),
-                              attempts=res.get("attempts"))
-
-        improved: Trace = res["improved"]
+        improved: Trace = res.improved
         improved.session_id = sid
         improved.parent_session_id = sid
         improved.improved = True
         improved.source = "traceforge-space"
 
-        # The splice engine gates before returning, but a structural check
-        # here is cheap and makes the Space's own contract explicit.
-        try:
-            from traceforge.validate import validate_structural
-            structural = validate_structural(improved)
-        except Exception as e:
-            structural = [f"validator crashed: {e}"]
-        if not structural:
-            # The ideal must be self-contained: a rewrite that drops the
-            # evidence but keeps the claim passes the source-grounding
-            # gate, yet teaches the model to assert facts it never saw.
-            try:
-                from traceforge.grounding import self_grounding_errors
-                structural = self_grounding_errors(improved)
-            except Exception as e:
-                structural = [f"self-grounding check crashed: {e}"]
-        if structural:
-            return self._fail(h, structural, started, route=res.get("route"),
-                              attempts=res.get("attempts"))
-
-        # Task bucket: heuristic only — the Space must not spend an LLM call
-        # on a label the dashboard can derive for free.
-        try:
-            from traceforge.classify import classify_heuristic
-            improved.task = classify_heuristic(improved).get("task")
-        except Exception:
-            pass
-
-        # Time sensitivity: measured on the RAW record (it may carry the
-        # `tools` array, which is what decides anchored vs sensitive) and on
-        # the ideal rewrite (did it actually call the retrieval tool?).
-        ts_raw = self._time_sensitivity(record)
-        ts_out = self._time_sensitivity(improved)
-
         # A no-op is not an ideal rewrite. The splice engine can return the
         # seed unchanged when the writer decides nothing needs changing, and
         # the judge accepts it because it violates nothing — but the Space
@@ -269,12 +349,12 @@ class SpacePipeline:
         # It is not a failure either: a seed that already reads as ideal
         # legitimately needs no edit. Record it as `no_change` so the UI can
         # say so instead of counting it against the visitor.
-        if _same_conversation(record, improved):
+        if res.no_change:
             return self._reject(
                 h, "no change needed: the rewrite is identical to the seed, "
                    "so the seed already reads as an ideal trace", started,
-                route=res.get("route"), attempts=res.get("attempts"),
-                time_sensitivity=ts_raw, no_change=True,
+                route=res.route, attempts=res.attempts,
+                time_sensitivity=res.time_sensitivity, no_change=True,
             )
 
         self.store.put_output(h, improved)
@@ -282,12 +362,12 @@ class SpacePipeline:
         row = self.store.update(
             h, status=DONE, finished_at=time.time(), duration_s=round(duration, 1),
             output_hash=output_hash(improved),
-            route=res.get("route") or "",
-            attempts=res.get("attempts") or 0,
+            route=res.route,
+            attempts=res.attempts,
             n_messages_out=len(improved.messages),
-            task=improved.task or rec.get("task") or "",
-            time_sensitivity=ts_raw,
-            time_sensitivity_improved=ts_out,
+            task=res.task or rec.get("task") or "",
+            time_sensitivity=res.time_sensitivity,
+            time_sensitivity_improved=res.time_sensitivity_improved,
             error="",
         )
         return row
@@ -311,17 +391,6 @@ class SpacePipeline:
             route=route or "", attempts=attempts or 0, error=reason, **extra,
         )
 
-    @staticmethod
-    def _time_sensitivity(obj: Any) -> dict:
-        try:
-            from traceforge.timesensitivity import detect
-            d = detect(obj)
-            return {k: d[k] for k in ("class", "label", "temporal_facts",
-                                      "retrieval_available", "retrieval_called",
-                                      "needs_rewrite", "score")}
-        except Exception as e:
-            return {"class": "", "label": f"unavailable: {e}"}
-
     # -------------------------------------------------------------- report
 
     def result(self, h: str) -> dict:

traceforge/splice.py

@@ -2940,6 +2940,14 @@ def improve_trace_splice(
         # vendor identity nor refusal phrasing — repair or drop the row
         ierrs = validate_identity(candidate.messages) if not gerrs else []
         gerrs = gerrs or ierrs
+        # Self-grounding: the ideal must carry its own evidence. A rewrite
+        # that drops the tool result but keeps the claim passes
+        # validate_grounding (the fact IS in the source trace) yet teaches
+        # the model to assert facts it never saw. Measured on 150 promoted
+        # traces before this gate existed: 6% would have failed it.
+        if not gerrs:
+            from traceforge.grounding import self_grounding_errors
+            gerrs = self_grounding_errors(candidate)
         if gerrs:
             _status(f"gates fail ({attempts})")
             # Record WHY the gate failed even when a repair is attempted —
@@ -3954,6 +3962,9 @@ def judge_artifact(
     errs = validate_structural(candidate) \
         or validate_grounding(candidate, trace) \
         or validate_identity(candidate.messages)
+    if not errs:
+        from traceforge.grounding import self_grounding_errors
+        errs = self_grounding_errors(candidate)
     if errs and all("last message role is 'tool'" in e for e in errs):
         # stale artifact from an earlier run that stopped mid-call: close
         # it here instead of failing a trace that is one row short
@@ -3965,6 +3976,9 @@ def judge_artifact(
             errs = validate_structural(candidate) \
                 or validate_grounding(candidate, trace) \
                 or validate_identity(candidate.messages)
+            if not errs:
+                from traceforge.grounding import self_grounding_errors
+                errs = self_grounding_errors(candidate)
     if errs:
         return {"ok": False,
                 "errors": [f"gate: {e}" for e in errs[:4]],