new taxonomy (#1023)

* new taxonomy

* sync the frontend taxonomy vocabulary with the backend enums

Drops thinking_diagnose in favour of thinking_correction, adds
implementing_correction, and renames testing_custom_edge_cases to
testing_edge_cases. The frontend union, labels, color vars and --tc-*
tokens now mirror the flat backend vocabulary, so the new kinds get their
fixed semantic color instead of an appearance-order phase slot.

The two retired kinds stay mapped on the frontend: stored summaries
still carry them, and each shares the slot its replacement took over.

---------

Co-authored-by: Rishi Desai <RishiDesai@users.noreply.github.com>
Co-authored-by: Pratyush Shukla <ps4534@nyu.edu>

Author: 3 people

backend/api/services/blocks/analyzer/trajectory/trajectory_component_block.py

@@ -20,15 +20,16 @@ class ExploreTrajectoryBlockTaxonomy(str, enum.Enum):
     THINKING_RECALL = "thinking_recall"
     THINKING_UNDERSTAND = "thinking_understand"
     THINKING_HYPOTHESIZE = "thinking_hypothesize"
-    THINKING_DIAGNOSE = "thinking_diagnose"
+    THINKING_CORRECTION = "thinking_correction"
 
 
 class ImplementTrajectoryBlockTaxonomy(str, enum.Enum):
     IMPLEMENTING = "implementing"
+    IMPLEMENTING_CORRECTION = "implementing_correction"
     WRITING_TESTS = "writing_tests"
     TESTING_PUBLIC = "testing_public"
     TESTING_CUSTOM = "testing_custom"
-    TESTING_CUSTOM_EDGE_CASES = "testing_custom_edge_cases"
+    TESTING_EDGE_CASES = "testing_edge_cases"
     DEBUGGING = "debugging"
 
 
@@ -84,8 +85,12 @@ def _drop_bad_elements(cls, data):
             return data
         data = dict(data)
         data["summary"] = str(data.get("summary") or "")
-        data["highlights"] = [h for h in (data.get("highlights") or []) if isinstance(h, dict)]
-        data["components"] = [c for c in (data.get("components") or []) if isinstance(c, dict)]
+        data["highlights"] = [
+            h for h in (data.get("highlights") or []) if isinstance(h, dict)
+        ]
+        data["components"] = [
+            c for c in (data.get("components") or []) if isinstance(c, dict)
+        ]
         return data
 
 
@@ -134,7 +139,9 @@ class TrajectoryBlock(Block):
 
     output_schema = TrajectoryOutput
 
-    def __init__(self, trajectory_input: TrajectoryInput, *, instructions_template: str) -> None:
+    def __init__(
+        self, trajectory_input: TrajectoryInput, *, instructions_template: str
+    ) -> None:
         self.trajectory_input = trajectory_input
         self._instructions_template = instructions_template
 
@@ -143,37 +150,66 @@ def sections(self) -> list[dict]:
         ti = self.trajectory_input
         taxonomy_values = [m.value for m in TrajectoryBlockTaxonomy]
         return [
-            {"name": "preamble", "raw_input": {}, "schema": _PreambleIn,
-             "formatter": lambda _d: tp.PREAMBLE},
-            {"name": "task",
-             "raw_input": {"task_name": ti.task_name, "instruction": ti.instruction},
-             "schema": _TaskIn, "formatter": self._fmt_task},
-            {"name": "outcome",
-             "raw_input": {"final_reward": ti.final_reward, "model_used": ti.model_used,
-                           "verifier_output": ti.verifier_output},
-             "schema": _OutcomeIn, "formatter": self._fmt_outcome},
-            {"name": "instructions", "raw_input": {}, "schema": _InstructionsIn,
-             "formatter": lambda _d: tp.instructions_section(
-                 self._instructions_template, taxonomy_values)},
-            {"name": "trajectory", "raw_input": {"trajectory": ti.trajectory},
-             "schema": _TrajectoryIn, "formatter": self._fmt_trajectory},
+            {
+                "name": "preamble",
+                "raw_input": {},
+                "schema": _PreambleIn,
+                "formatter": lambda _d: tp.PREAMBLE,
+            },
+            {
+                "name": "task",
+                "raw_input": {"task_name": ti.task_name, "instruction": ti.instruction},
+                "schema": _TaskIn,
+                "formatter": self._fmt_task,
+            },
+            {
+                "name": "outcome",
+                "raw_input": {
+                    "final_reward": ti.final_reward,
+                    "model_used": ti.model_used,
+                    "verifier_output": ti.verifier_output,
+                },
+                "schema": _OutcomeIn,
+                "formatter": self._fmt_outcome,
+            },
+            {
+                "name": "instructions",
+                "raw_input": {},
+                "schema": _InstructionsIn,
+                "formatter": lambda _d: tp.instructions_section(
+                    self._instructions_template, taxonomy_values
+                ),
+            },
+            {
+                "name": "trajectory",
+                "raw_input": {"trajectory": ti.trajectory},
+                "schema": _TrajectoryIn,
+                "formatter": self._fmt_trajectory,
+            },
         ]
 
     @staticmethod
     def _fmt_task(d: _TaskIn) -> str:
-        instruction = _truncate(d.instruction) if d.instruction is not None else "[unavailable]"
+        instruction = (
+            _truncate(d.instruction) if d.instruction is not None else "[unavailable]"
+        )
         return tp.task_section(d.task_name, instruction)
 
     @staticmethod
     def _fmt_outcome(d: _OutcomeIn) -> str:
         reward = f"{d.final_reward}" if d.final_reward is not None else "[unavailable]"
-        verifier = _truncate(d.verifier_output) if d.verifier_output is not None else "[unavailable]"
+        verifier = (
+            _truncate(d.verifier_output)
+            if d.verifier_output is not None
+            else "[unavailable]"
+        )
         model = d.model_used or "[unavailable]"
         return tp.outcome_section(reward, verifier, model)
 
     @staticmethod
     def _fmt_trajectory(d: _TrajectoryIn) -> str:
         from api.services.summarize_trajectory import preprocess
+
         return tp.trajectory_section(json.dumps(preprocess(d.trajectory)))
 
     # ---- parsing (parse is inherited; this filters elements) ----
@@ -187,10 +223,15 @@ def _valid_step_ids(self) -> set[int]:
     def filter_output(self, parsed: TrajectoryOutput) -> TrajectoryOutput:
         valid = self._valid_step_ids()
         highlights = [
-            {"step_id": h["step_id"], "title": str(h.get("title") or "").strip(),
-             "why": str(h.get("why") or "").strip()}
+            {
+                "step_id": h["step_id"],
+                "title": str(h.get("title") or "").strip(),
+                "why": str(h.get("why") or "").strip(),
+            }
             for h in parsed.highlights
-            if isinstance(h, dict) and isinstance(h.get("step_id"), int) and h["step_id"] in valid
+            if isinstance(h, dict)
+            and isinstance(h.get("step_id"), int)
+            and h["step_id"] in valid
         ]
         components: list[dict] = []
         for c in parsed.components:
@@ -202,11 +243,13 @@ def filter_output(self, parsed: TrajectoryOutput) -> TrajectoryOutput:
             ids = [s for s in m.step_ids if s in valid]
             if not ids:
                 continue
-            components.append({
-                "step_ids": ids,
-                "trajectory_component": m.trajectory_component.value,
-                "summary": m.summary,
-            })
+            components.append(
+                {
+                    "step_ids": ids,
+                    "trajectory_component": m.trajectory_component.value,
+                    "summary": m.summary,
+                }
+            )
         return TrajectoryOutput(
             summary=str(parsed.summary or "").strip(),
             highlights=highlights,
@@ -227,15 +270,22 @@ def timestamp_ms(step: dict) -> float | None:
             if not isinstance(value, str):
                 return None
             try:
-                return datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp() * 1000
+                return (
+                    datetime.fromisoformat(value.replace("Z", "+00:00")).timestamp()
+                    * 1000
+                )
             except ValueError:
                 return None
 
         def duration_ms(index: int, step: dict) -> int:
             if index == 0:
                 return 0
             current = timestamp_ms(step)
-            previous = timestamp_ms(steps[index - 1]) if isinstance(steps[index - 1], dict) else None
+            previous = (
+                timestamp_ms(steps[index - 1])
+                if isinstance(steps[index - 1], dict)
+                else None
+            )
             if current is None or previous is None:
                 return 0
             return max(0, round(current - previous))
@@ -247,17 +297,21 @@ def duration_ms(index: int, step: dict) -> int:
                 for step_id in component["step_ids"]
                 if step_id in step_by_id
             ]
-            components.append({
-                **component,
-                # These fields are derived from the immutable trajectory rather
-                # than supplied by the LLM, so consumers can safely aggregate them.
-                "tool_count": sum(
-                    len(step.get("tool_calls") or [])
-                    for _, step in component_steps
-                    if isinstance(step.get("tool_calls"), list)
-                ),
-                "duration_ms": sum(duration_ms(index, step) for index, step in component_steps),
-            })
+            components.append(
+                {
+                    **component,
+                    # These fields are derived from the immutable trajectory rather
+                    # than supplied by the LLM, so consumers can safely aggregate them.
+                    "tool_count": sum(
+                        len(step.get("tool_calls") or [])
+                        for _, step in component_steps
+                        if isinstance(step.get("tool_calls"), list)
+                    ),
+                    "duration_ms": sum(
+                        duration_ms(index, step) for index, step in component_steps
+                    ),
+                }
+            )
         return {
             "schema_version": "5",
             "model": model,

frontend/src/app/globals.css

@@ -215,8 +215,9 @@
     --tc-thinking-recall: #1baf7a;
     --tc-thinking-understand: #2a78d6;
     --tc-thinking-hypothesize: #a184ea;
-    --tc-thinking-diagnose: #4a3aa7;
+    --tc-thinking-correction: #4a3aa7;
     --tc-implementing: #eb6834;
+    --tc-implementing-correction: #784000;
     --tc-writing-tests: #eda100;
     --tc-testing-public: #e87ba4;
     --tc-testing-custom: #c94592;
@@ -281,8 +282,9 @@
     --tc-thinking-recall: #199e70;
     --tc-thinking-understand: #3987e5;
     --tc-thinking-hypothesize: #9085e9;
-    --tc-thinking-diagnose: #7a68d8;
+    --tc-thinking-correction: #7a68d8;
     --tc-implementing: #d95926;
+    --tc-implementing-correction: #b85850;
     --tc-writing-tests: #c98500;
     --tc-testing-public: #ce6b98;
     --tc-testing-custom: #d55181;

frontend/src/lib/trajectory-metrics.ts

@@ -49,13 +49,19 @@ const COMPONENT_COLOR_VARS: Record<string, string> = {
   thinking_recall: "var(--tc-thinking-recall)",
   thinking_understand: "var(--tc-thinking-understand)",
   thinking_hypothesize: "var(--tc-thinking-hypothesize)",
-  thinking_diagnose: "var(--tc-thinking-diagnose)",
+  thinking_correction: "var(--tc-thinking-correction)",
   implementing: "var(--tc-implementing)",
+  implementing_correction: "var(--tc-implementing-correction)",
   writing_tests: "var(--tc-writing-tests)",
   testing_public: "var(--tc-testing-public)",
   testing_custom: "var(--tc-testing-custom)",
-  testing_custom_edge_cases: "var(--tc-testing-edge)",
+  testing_edge_cases: "var(--tc-testing-edge)",
   debugging: "var(--tc-debugging)",
+  // Retired kinds, kept so stored summaries keep their fixed color rather than
+  // falling through to appearance-order phase slots. Each shares the slot its
+  // replacement took over; the two vocabularies never co-occur in one summary.
+  thinking_diagnose: "var(--tc-thinking-correction)",
+  testing_custom_edge_cases: "var(--tc-testing-edge)",
   // Synthetic bucket for steps no component claims — always neutral gray.
   other: "var(--phase-other)",
 };

frontend/src/lib/trajectory-segments.ts

@@ -10,13 +10,16 @@ const COMPONENT_LABELS: Record<TrajectoryComponentKind, string> = {
   thinking_recall: "Recalling",
   thinking_understand: "Understanding",
   thinking_hypothesize: "Hypothesizing",
-  thinking_diagnose: "Diagnosing",
+  thinking_correction: "Correcting course",
   implementing: "Implementing",
+  implementing_correction: "Correcting implementation",
   writing_tests: "Writing tests",
   testing_public: "Running public tests",
   testing_custom: "Running custom tests",
-  testing_custom_edge_cases: "Testing edge cases",
+  testing_edge_cases: "Testing edge cases",
   debugging: "Debugging",
+  thinking_diagnose: "Diagnosing",
+  testing_custom_edge_cases: "Testing edge cases",
 };
 
 /** Display label for a taxonomy value; unknown values degrade to de-snaked text. */

frontend/src/lib/types.ts

@@ -693,13 +693,17 @@ export type TrajectoryComponentKind =
   | "thinking_recall"
   | "thinking_understand"
   | "thinking_hypothesize"
-  | "thinking_diagnose"
+  | "thinking_correction"
   | "implementing"
+  | "implementing_correction"
   | "writing_tests"
   | "testing_public"
   | "testing_custom"
-  | "testing_custom_edge_cases"
-  | "debugging";
+  | "testing_edge_cases"
+  | "debugging"
+  // Retired from the backend enum, but stored summaries still carry them.
+  | "thinking_diagnose"
+  | "testing_custom_edge_cases";
 
 export interface TrajectoryComponent {
   step_ids: number[];