Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,17 @@
+.git
+.venv
+venv
+__pycache__
+**/__pycache__
+*.pyc
+**/*.pyc
+.DS_Store
+.env
+.streamlit/secrets.toml
+.playwright
+hf_space/runs
+runs
+*.zip
+**/.pytest_cache
+**/node_modules
+agent-transcripts

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+replay_traces/2505.17978/processed_papers/2505.17978/usage_citing_paragraphs.json filter=lfs diff=lfs merge=lfs -text

.streamlit/config.toml

@@ -0,0 +1,22 @@
+[browser]
+gatherUsageStats = false
+
+[server]
+headless = true
+# Hugging Face Spaces / Docker bind on all interfaces; local overrides via CLI are fine.
+address = "0.0.0.0"
+port = 7860
+fileWatcherType = "auto"
+runOnSave = false
+
+[client]
+toolbarMode = "viewer"
+showSidebarNavigation = false
+
+[theme]
+base = "light"
+primaryColor = "#0f6b5c"
+backgroundColor = "#e7eef0"
+secondaryBackgroundColor = "#f4f8f7"
+textColor = "#13201d"
+font = "sans serif"

.streamlit/credentials.toml

@@ -0,0 +1,2 @@
+[general]
+email = ""

Deep-Citation/Data/class_def.json

@@ -0,0 +1,23 @@
+{
+    "acl": 
+        {
+            "BACKGROUND": "The citation provides relevant information for the domain that the present paper discusses.",
+            "MOTIVATION": "The citation illustrates the need for data, goals, methods, etc that is proposed in the present paper.",
+            "USES": "The present paper uses data, methods, etc., from the paper associated with the citation.",
+            "EXTENDS": "The present paper extends the data, methods, etc. from the paper associated with the citation.",
+            "COMPAREORCONTRAST": "The present paper expresses similarity / differences to the citation.",
+            "FUTURE": "The citation is a potential avenue for future work of the present paper."
+        },
+    "kim":
+        {
+            "Used": "The present paper uses at least one method that is proposed in the paper associated with the citation.",
+            "Not used": "The present paper does not use or extend any methods that is proposed in the paper associated with the citation.",
+            "Extended": "The present paper uses an extended / modified version of the method proposed in the paper associated with the citation."
+        },
+    "scicite":
+        {
+            "Background": "The citation states, mentions, or points to the background information giving more context about a problem, concept, approach, topic, or importance of the problem that is discussed in the present paper.",
+            "Method": "The present paper uses a method, tool, approach or dataset that is proposed in the paper associated with the citation.",
+            "Result": "The present paper compares its results/findings with the results/findings of the paper associated with the citation."
+        }
+}

Deep-Citation/Model/__init__.py

@@ -0,0 +1 @@
+from .model import LanguageModel, MultiHeadLanguageModel

Deep-Citation/Model/model.py

@@ -0,0 +1,89 @@
+import os
+import torch
+import torch.nn as nn
+
+from typing import List
+from transformers import AutoModel
+
+def mask_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0] #First element of model_output contains all token embeddings
+    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+class LanguageModel(nn.Module):
+    def __init__(self, 
+                 modelname: str, 
+                 device: str, 
+                 readout: str
+        ):
+        super(LanguageModel, self).__init__()
+        self.device = device
+        self.modelname = modelname
+        self.readout_fn = readout
+
+        self.model = AutoModel.from_pretrained(modelname)
+        self.hidden_size = self.model.config.hidden_size
+
+    def readout(self, model_inputs, model_outputs, readout_masks=None):
+        if self.readout_fn == 'cls':
+            if 'bert' in self.modelname or 'deberta' in self.modelname:
+                text_representations = model_outputs.last_hidden_state[:, 0]
+            elif 'xlnet' in self.modelname:
+                text_representations = model_outputs.last_hidden_state[:, -1]
+            else:
+                raise ValueError('Invalid model name {} for the cls readout.'.format(self.modelname))
+        elif self.readout_fn == 'mean':
+            text_representations = mask_pooling(model_outputs, model_inputs['attention_mask'])
+        elif self.readout_fn == 'ch' and readout_masks is not None:
+            text_representations = mask_pooling(model_outputs, readout_masks)
+        else:
+            raise ValueError('Invalid readout function.')
+        return text_representations
+
+    def _lm_forward(self, tokens):
+        tokens = tokens.to(self.device)
+        if 'readout_mask' in tokens:
+            readout_mask = tokens.pop('readout_mask')
+        else:
+            readout_mask = None
+        outputs = self.model(**tokens)
+        return self.readout(tokens, outputs, readout_mask)
+
+    def forward(self):
+        raise NotImplementedError
+
+    def save_pretrained(self, modeldir):
+        model_filename = os.path.join(modeldir, 'checkpoint.pt')
+        torch.save(self.state_dict(), model_filename)
+
+    def load_pretrained(self, modeldir):
+        model_filename = os.path.join(modeldir, 'checkpoint.pt')
+        self.load_state_dict(torch.load(model_filename))
+
+class MultiHeadLanguageModel(LanguageModel):
+    def __init__(self, 
+                 modelname: str, 
+                 device: str, 
+                 readout: str, 
+                 num_classes: List
+        ):
+        super().__init__(
+            modelname,
+            device, 
+            readout
+        )
+
+        self.num_classes = num_classes
+        self.lns = nn.ModuleList([nn.Linear(self.hidden_size, num_class) for num_class in num_classes])
+
+    def forward(self, input_tokens, input_head_indices, class_tokens, class_head_indices):
+        head_indices = torch.unique(input_head_indices)
+        text_representations = self._lm_forward(input_tokens)
+
+        final_preds = {}
+        for i in head_indices:
+            if torch.any(input_head_indices == i):
+                final_preds[i.item()] = self.lns[i.item()](text_representations[input_head_indices == i])
+            else:
+                final_preds[i.item()] = torch.tensor([]).to(self.device)
+        return final_preds

Deep-Citation/Workspace/acl_scicite_wksp_trl/args.txt

@@ -0,0 +1,21 @@
+Namespace(dataset='acl-scicite',
+lambdas='1-0.063',
+data_dir='Data',
+workspace='Workspace/acl_scicite_wksp_trl',
+class_definition='Data/class_def.json',
+batch_size=32,
+lr=5e-05,
+decay_rate=0.5,
+decay_step=5,
+num_epochs=10,
+scheduler='slanted',
+dropout_rate=0.2,
+l2=0.0,
+device='cuda',
+tol=10,
+inference_only=False,
+seed=1,
+lm='scibert',
+max_length=512,
+batch_size_factor=2,
+readout='ch')

Deep-Citation/Workspace/acl_scicite_wksp_trl/best_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e45ab11942439f80a121dad5b2d9da392470e0cedf6a7335991fa0a1f616dcb2
+size 439784777

Deep-Citation/data.py

@@ -0,0 +1,211 @@
+import os
+import json
+import copy
+import torch
+import scipy
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+from scipy.special import softmax
+
+from transformers import AutoTokenizer
+
+class CollateFn(object):
+    def __init__(self, modelname, class_definitions=None, instance_weights=False):
+        self.instance_weights = instance_weights
+        use_fast = False if 'deberta' in modelname else True
+        self.tokenizer = AutoTokenizer.from_pretrained(modelname, use_fast=use_fast)
+        cited_ids = self.tokenizer.encode('<CITED HERE>', add_special_tokens=False)
+        self.cited_here_tokens = torch.tensor(cited_ids, dtype=torch.long)
+
+        if class_definitions is not None:
+            self.class_definitions = []
+            self.class_head_indices = []
+            for i, defs in enumerate(class_definitions):
+                self.class_definitions += defs
+                self.class_head_indices.append(i * torch.ones(len(defs), dtype=torch.long))
+            self.class_head_indices = torch.cat(self.class_head_indices, dim=0)
+            self.class_tokens = self.tokenizer(
+                self.class_definitions,
+                return_tensors="pt",
+                max_length=512,
+                truncation=True,
+                padding=True
+            )
+
+    def _get_readout_mask(self, tokens):
+        # cited_here_tokens = torch.tensor([962, 8412, 1530, 1374])
+        readout_mask = torch.zeros_like(tokens['input_ids'], dtype=torch.bool)
+
+        batch_size = tokens['input_ids'].size(0)
+        l = tokens['input_ids'].size(1)
+        ctk_l = self.cited_here_tokens.size(0)
+        for b in range(batch_size):
+            for i in range(1, l - ctk_l):
+                if torch.equal(tokens['input_ids'][b, i:i+ctk_l], self.cited_here_tokens):
+                    readout_mask[b, i:i+ctk_l] = True
+            if not readout_mask[b].any():
+                # Fallback to CLS if the citation marker isn't matched.
+                readout_mask[b, 0] = True
+        return readout_mask
+
+    def _tokenize_context(self, context):
+        tokens = self.tokenizer(
+            context,
+            return_tensors="pt",
+            max_length=512,
+            truncation=True,
+            padding=True
+        )
+        tokens['readout_mask'] = self._get_readout_mask(
+            tokens
+        )
+
+        return tokens
+
+    def __call__(self, samples):
+        if self.instance_weights:
+            text, labels, ds_indices, instance_weights = list(map(list, zip(*samples)))
+            batched_text = self._tokenize_context(text)
+            labels = torch.stack(labels)
+            ds_indices = torch.stack(ds_indices)
+            instance_weights = torch.stack(instance_weights)
+            return batched_text, labels, ds_indices, instance_weights
+        else:
+            text, labels, ds_indices = list(map(list, zip(*samples)))
+            batched_text = self._tokenize_context(text)
+            labels = torch.stack(labels)
+            ds_indices = torch.stack(ds_indices)
+
+            return batched_text, labels, ds_indices, copy.deepcopy(self.class_tokens), self.class_head_indices
+
+class Dataset(object):
+    def __init__(self, dataframe, class_definitions, lmbd=1.0):
+        self.class_definitions = class_definitions
+        self.lmbd = lmbd
+        self._load_data(dataframe)
+
+    def __len__(self):
+        return len(self.labels)
+
+    def __getitem__(self, idx):
+        '''Get datapoint with index'''
+        return (self.text[idx], self.labels[idx], self.ds_index[idx])
+
+    def _load_data(self, annotated_data):
+        self.labels = torch.LongTensor(annotated_data['label'].tolist())
+        self.original_labels = torch.LongTensor(annotated_data['label'].tolist())
+        self.ds_index = torch.zeros_like(self.original_labels)
+        self.text = annotated_data['context'].tolist()
+
+class MultiHeadDatasets(object):
+    def __init__(self, datasets, batch_size_factor=2):
+        self.text = []
+        self.ds_index = []
+        self.labels = []
+        self.class_definitions = []
+        self.lambdas = []
+
+        self.dataset_sizes = [len(d.labels) for d in datasets]
+        if len(self.dataset_sizes) > 1:
+            if sum(self.dataset_sizes) / self.dataset_sizes[0] <= batch_size_factor:
+                self.sample_auxiliary = False
+                self.adjusted_batch_size_factor = sum(self.dataset_sizes) / self.dataset_sizes[0]
+            else:
+                self.sample_auxiliary = True
+                self.sample_distribution = np.array([d.lmbd for d in datasets[1:]]) / sum([d.lmbd for d in datasets[1:]])
+                self.adjusted_batch_size_factor = batch_size_factor
+        else:
+            self.sample_auxiliary = False
+            self.adjusted_batch_size_factor = 1
+
+        for i, d in enumerate(datasets):
+            self.text += d.text
+            self.ds_index.append(i * torch.ones(len(d.text), dtype=torch.long))
+            self.labels.append(d.labels)
+            self.class_definitions.append(d.class_definitions)
+            self.lambdas.append(d.lmbd)
+        self.labels = torch.cat(self.labels, dim=0)
+        self.ds_index = torch.cat(self.ds_index, dim=0)
+    
+    def sample_auxiliary_instace(self):
+        sampled_dataset_idx = np.random.choice(
+            np.arange(1, len(self.dataset_sizes)), 
+            p=self.sample_distribution
+        )
+        instance_idx = np.random.choice(
+            self.dataset_sizes[sampled_dataset_idx]
+        ) + sum(self.dataset_sizes[:sampled_dataset_idx])
+        return instance_idx
+
+    def __len__(self):
+        if self.sample_auxiliary: # if the auxiliary dataset is larger than the main dataset
+            return self.dataset_sizes[0] * self.adjusted_batch_size_factor
+        return len(self.labels)
+    
+    def __getitem__(self, idx):
+        '''Get datapoint with index'''
+        if idx < self.dataset_sizes[0] or not self.sample_auxiliary:
+            return (self.text[idx], self.labels[idx], self.ds_index[idx])
+        else:
+            real_idx = self.sample_auxiliary_instace()
+            return (self.text[real_idx], self.labels[real_idx], self.ds_index[real_idx])
+
+def load_class_definitions(filename):
+    with open(filename, 'r') as f:
+        class_definitions = json.load(f)
+    
+    results = {k:{} for k in class_definitions.keys()}
+    for k, v in class_definitions.items():
+        for kk, vv in v.items():
+            results[k][kk.lower()] = vv
+    return results
+
+def create_data_channels(filename, class_definition_filename, split=None, lmbd=1.0):
+    data = pd.read_csv(filename, sep='\t')
+    data = data.fillna(' ')
+
+    print('Number of data instance: {}'.format(data.shape[0]))
+
+    # map labels to ids
+    unique_labels = data['label'].unique().tolist()
+    label2id = {lb: i for i, lb in enumerate(unique_labels)}
+    
+    data['label'] = data['label'].apply(
+        lambda x: label2id[x])
+
+    data_train = data[data['split'] == 'train'].reset_index()
+    data_val = data[data['split'] == 'val'].reset_index()
+    data_test = data[data['split'] == 'test'].reset_index()
+
+    class_definitions = load_class_definitions(class_definition_filename)
+    dataname = filename.split('/')[-1].split('.')[0]
+    data_class_definitions = [class_definitions[dataname][lb.lower()] for lb in unique_labels]
+
+    train_data = Dataset(data_train, data_class_definitions, lmbd=lmbd)
+    val_data = Dataset(data_val, data_class_definitions, lmbd=lmbd)
+    test_data = Dataset(data_test, data_class_definitions, lmbd=lmbd)
+
+    return train_data, val_data, test_data, unique_labels
+
+def create_single_data_object(filename, class_definition_filename, split=None, lmbd=1.0):
+    data = pd.read_csv(filename, sep='\t')
+    data = data.fillna(' ')
+
+    print('Number of data instance: {}'.format(data.shape[0]))
+
+    # map labels to ids
+    unique_labels = data['label'].unique()
+    label2id = {lb: i for i, lb in enumerate(unique_labels)}
+    
+    data['label'] = data['label'].apply(
+        lambda x: label2id[x])
+
+    class_definitions = load_class_definitions(class_definition_filename)
+    dataname = filename.split('/')[-1].split('.')[0]
+    data_class_definitions = [class_definitions[dataname][lb.lower()] for lb in unique_labels]
+
+    if split is None:
+        return Dataset(data, data_class_definitions, lmbd=lmbd), unique_labels
+    else:
+        return Dataset(data[data['split'] == split].reset_index(), data_class_definitions, lmbd=lmbd), unique_labels

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    STREAMLIT_SERVER_HEADLESS=true \
+    STREAMLIT_BROWSER_GATHER_USAGE_STATS=false \
+    PLAYWRIGHT_BROWSERS_PATH=/app/.playwright \
+    HOME=/tmp
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt /app/requirements.txt
+COPY hf_space/requirements.txt /app/hf_space/requirements.txt
+RUN python -m pip install --upgrade pip && \
+    pip install -r requirements.txt
+
+# Chromium for SciPath Live Run (websearch_deep crawl tool).
+RUN mkdir -p /app/.playwright && \
+    python -m playwright install --with-deps chromium
+
+COPY . /app
+
+# HF Space secrets (GEMINI_API_KEY, etc.) are injected as env vars at runtime.
+EXPOSE 7860
+
+CMD ["streamlit", "run", "hf_space/streamlit_app.py", \
+     "--server.address", "0.0.0.0", \
+     "--server.port", "7860", \
+     "--browser.gatherUsageStats", "false"]

README.md

@@ -1,10 +1,233 @@
 ---
 title: SciPaths Demo
-emoji: 🏢
+emoji: 🔬
 colorFrom: blue
-colorTo: blue
+colorTo: green
 sdk: docker
 pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SciPaths Demo
+
+Self-contained demo of **SciPaths** (annotation process) and **SciFy CodeAgent** (system run / live run) on SciPaths claims.
+
+The Hugging Face Space launches Streamlit from `hf_space/streamlit_app.py`. This folder is deployable on its own — it does not depend on sibling repos such as `dryrun/`.
+
+## Citation
+
+If you find this useful, please cite our paper as:
+
+```bibtex
+@misc{chamoun2026scipathsforecastingpathwaysscientific,
+      title={SciPaths: Forecasting Pathways to Scientific Discovery}, 
+      author={Eric Chamoun and Yizhou Chi and Yulong Chen and Rui Cao and Zifeng Ding and Michalis Korakakis and Andreas Vlachos},
+      year={2026},
+      eprint={2605.14600},
+      archivePrefix={arXiv},
+      primaryClass={cs.CL},
+      url={https://arxiv.org/abs/2605.14600}, 
+}
+```
+
+Paper URL: https://arxiv.org/abs/2605.14600
+
+## Required Secrets
+
+Set this in the Space settings before publishing:
+
+```text
+GEMINI_API_KEY=<Google Gemini API key>
+```
+
+Optional, for saving completed run artifacts to a Hugging Face Dataset:
+
+```text
+HF_WRITE_TOKEN=<Hugging Face write token>
+RUNS_REPO_ID=<owner/dataset-name>
+RUNS_REPO_TYPE=dataset
+```
+
+Optional, for higher Semantic Scholar limits:
+
+```text
+SEMANTIC_SCHOLAR_API_KEY=<Semantic Scholar API key>
+```
+
+## Run The Demo Locally
+
+```bash
+pip install -r requirements.txt
+streamlit run hf_space/streamlit_app.py
+```
+
+Then enter an arXiv URL or ID, for example:
+
+```text
+https://arxiv.org/abs/2211.08788
+```
+
+The app writes each run under:
+
+```text
+hf_space/runs/<job_id>/
+```
+
+## Run One Example From The Command Line
+
+This example stores all intermediate files under `runs/example/processed_papers`.
+
+```bash
+mkdir -p runs/example
+printf '[{"id":"2211.08788","title":"","id_type":"ArXiv"}]\n' > runs/example/input_ids.json
+
+python src/step_01_fetch/fetch_metadata.py \
+  --ids runs/example/input_ids.json \
+  --outdir runs/example/processed_papers
+
+python src/step_02_mark_citations/replace_citation_markers.py \
+  --root runs/example/processed_papers
+
+python src/step_03_usage_contexts/build_usage_contexts.py \
+  --root runs/example/processed_papers \
+  --out-name usage_contexts.json
+
+python src/step_04_label_citations/label_citation_functions.py \
+  --root runs/example/processed_papers \
+  --model-path Deep-Citation/Workspace/acl_scicite_wksp_trl/best_model.pt \
+  --model-data-dir Deep-Citation/Data \
+  --model-class-def Deep-Citation/Data/class_def.json \
+  --model-lm scibert \
+  --device cpu
+
+python src/step_05_verify_uses_extends/verify_uses_extends.py \
+  --root runs/example/processed_papers \
+  --k 0 \
+  --batch-size 25
+
+python src/step_06_extract_paragraphs/extract_arxiv_paragraphs.py \
+  --root runs/example/processed_papers
+
+python src/step_07_extract_and_refine/extract_contributions_from_citations.py \
+  --root runs/example/processed_papers
+
+python src/step_07_extract_and_refine/refine_and_filter_clusters_llm.py \
+  --root runs/example/processed_papers \
+  --inplace \
+  --overwrite
+
+PYTHONPATH=src \
+python -m step_08_annotation.cli run \
+  --paper-dir runs/example/processed_papers/2211.08788 \
+  --provider gemini \
+  --model gemini/gemini-3.1-pro-preview \
+  --formatter-model gemini/gemini-3.1-pro-preview \
+  --judge-model gemini/gemini-3.1-pro-preview \
+  --candidate-count 3 \
+  --output-root runs/example/two_pass_outputs
+```
+
+The final UI payload is written as `pass_2_ui_payload.json` inside the annotation run directory printed by the last command.
+
+## Run Each Step On A Set Of Papers
+
+Create an ID file with one entry per paper:
+
+```json
+[
+  {"id": "2211.08788", "title": "", "id_type": "ArXiv"},
+  {"id": "2311.14919", "title": "", "id_type": "ArXiv"}
+]
+```
+
+Save it as `runs/batch/input_ids.json`, then run:
+
+```bash
+mkdir -p runs/batch
+
+# 1. Fetch metadata + LaTeX for each input paper.
+python src/step_01_fetch/fetch_metadata.py \
+  --ids runs/batch/input_ids.json \
+  --outdir runs/batch/processed_papers
+
+# 2. Add explicit citation markers to the target-paper text.
+python src/step_02_mark_citations/replace_citation_markers.py \
+  --root runs/batch/processed_papers
+
+# 3. Build downstream citation usage contexts.
+python src/step_03_usage_contexts/build_usage_contexts.py \
+  --root runs/batch/processed_papers \
+  --out-name usage_contexts.json
+
+# 4. Label citation functions with the bundled Deep-Citation classifier.
+python src/step_04_label_citations/label_citation_functions.py \
+  --root runs/batch/processed_papers \
+  --model-path Deep-Citation/Workspace/acl_scicite_wksp_trl/best_model.pt \
+  --model-data-dir Deep-Citation/Data \
+  --model-class-def Deep-Citation/Data/class_def.json \
+  --model-lm scibert \
+  --device cpu
+
+# 5. Verify USES/EXTENDS citations with an LLM.
+python src/step_05_verify_uses_extends/verify_uses_extends.py \
+  --root runs/batch/processed_papers \
+  --k 0 \
+  --batch-size 25
+
+# 6. Extract arXiv paragraphs from downstream citing papers.
+python src/step_06_extract_paragraphs/extract_arxiv_paragraphs.py \
+  --root runs/batch/processed_papers
+
+# 7. Extract downstream contribution clusters, then merge/filter them.
+python src/step_07_extract_and_refine/extract_contributions_from_citations.py \
+  --root runs/batch/processed_papers
+
+python src/step_07_extract_and_refine/refine_and_filter_clusters_llm.py \
+  --root runs/batch/processed_papers \
+  --inplace \
+  --overwrite
+
+# 8. Annotate each ready paper: target contributions, enabling contributions, and groundings.
+for paper_dir in runs/batch/processed_papers/*; do
+  [ -d "$paper_dir" ] || continue
+  [ -f "$paper_dir/usage_discovery_from_contributions.json" ] || continue
+  PYTHONPATH=src \
+  python -m step_08_annotation.cli run \
+    --paper-dir "$paper_dir" \
+    --provider gemini \
+    --model gemini/gemini-3.1-pro-preview \
+    --formatter-model gemini/gemini-3.1-pro-preview \
+    --judge-model gemini/gemini-3.1-pro-preview \
+    --candidate-count 3 \
+    --output-root runs/batch/two_pass_outputs
+done
+```
+
+## Pipeline Steps
+
+1. **Fetch metadata + LaTeX.** Downloads target-paper metadata, references, citing-paper metadata, and arXiv source where available.
+2. **Add citation markers.** Inserts normalized citation markers into the target paper so downstream citation contexts can be aligned.
+3. **Build usage contexts.** Collects text windows around downstream citations to the target paper.
+4. **Label citation functions.** Uses the bundled Deep-Citation classifier to label citation contexts as background, use, extension, comparison, and related categories.
+5. **Verify USES/EXTENDS.** Uses an LLM to check whether candidate downstream citations genuinely use or extend the target paper.
+6. **Extract arXiv paragraphs.** Retrieves fuller paragraphs from citing papers so the system has enough context for contribution extraction.
+7. **Extract and refine target-contribution clusters.** Extracts what downstream papers use the target paper for, clusters near-duplicates, and filters weak/non-usage evidence.
+8. **Annotate pathways.** Derives target contributions from the refined clusters, decomposes each into enabling contributions, selects primary groundings, and records additional grounding studies.
+
+## Important Files
+
+```text
+hf_space/streamlit_app.py                  Streamlit UI
+hf_space/runner.py                         Orchestrates steps 1-7 for the UI
+hf_space/streamlit_config.py               Example papers and tab names
+src/common/                                Shared LLM and paper-package utilities
+src/step_01_fetch/                         Metadata, references, citations, and LaTeX
+src/step_02_mark_citations/                Citation-marker insertion
+src/step_03_usage_contexts/                Downstream usage-context construction
+src/step_04_label_citations/               Deep-Citation citation-function labeling
+src/step_05_verify_uses_extends/           LLM verification of USES/EXTENDS citations
+src/step_06_extract_paragraphs/            ArXiv paragraph extraction from citing papers
+src/step_07_extract_and_refine/            Contribution extraction and cluster refinement
+src/step_08_annotation/                    Target/enabling contribution annotation and grounding
+Deep-Citation/                             Bundled citation-function classifier assets
+```

app.py

@@ -0,0 +1,5 @@
+from hf_space.streamlit_app import main
+
+
+if __name__ == "__main__":
+    main()

docker-compose.neo4j.yml

@@ -0,0 +1,19 @@
+# Optional dedicated Neo4j if ports 7474/7687 are free.
+# By default the app uses whatever answers bolt://localhost:7687
+# (NEO4J_URI / NEO4J_USER / NEO4J_PASSWORD).
+services:
+  neo4j:
+    image: neo4j:5.26-community
+    container_name: scipaths-neo4j
+    ports:
+      - "7475:7474"
+      - "7688:7687"
+    environment:
+      NEO4J_AUTH: neo4j/scipaths123
+      NEO4J_PLUGINS: '["apoc"]'
+      NEO4J_dbms_memory_heap_max__size: 1G
+    volumes:
+      - scipaths_neo4j_data:/data
+
+volumes:
+  scipaths_neo4j_data:

hf_space/build_replay_traces.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""Run the demo example papers end-to-end and save replay traces."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+SRC = Path(__file__).resolve().parent
+REPO_ROOT = SRC.parent
+for extra in (SRC, REPO_ROOT / "src"):
+    extra_str = str(extra)
+    if extra_str not in sys.path:
+        sys.path.insert(0, extra_str)
+
+from dotenv import load_dotenv
+
+load_dotenv(REPO_ROOT / ".env")
+load_dotenv(REPO_ROOT.parent / "dryrun" / ".env", override=False)
+
+# Align Gemini env aliases used across the repo.
+if not os.getenv("GEMINI_API_KEY"):
+    for alt in ("GOOGLE_GENAI_API_KEY", "GOOGLE_API_KEY"):
+        if os.getenv(alt):
+            os.environ["GEMINI_API_KEY"] = os.environ[alt]
+            break
+
+import runner as runner_module
+from runner import PipelineConfig
+from common.paper_package import load_paper_package
+from step_08_annotation.pipeline import TwoPassAnnotationPipeline
+from streamlit_config import EXAMPLES
+
+REPLAY_ROOT = REPO_ROOT / "replay_traces"
+WORK_ROOT = REPO_ROOT / "hf_space" / "runs" / "replay_build"
+
+
+def _env(name: str, default: str) -> str:
+    return (os.getenv(name) or default).strip()
+
+
+def _load_json(path: Path):
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _copy_if_exists(src: Path, dst: Path) -> bool:
+    if not src.exists():
+        return False
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if src.is_dir():
+        if dst.exists():
+            shutil.rmtree(dst)
+        shutil.copytree(src, dst)
+    else:
+        shutil.copy2(src, dst)
+    return True
+
+
+def _run_annotation(paper_dir: Path, annotation_root: Path) -> tuple[dict | None, Path | None, str | None]:
+    discovery = _load_json(paper_dir / "usage_discovery_from_contributions.json") or {}
+    clusters = discovery.get("clusters") or []
+    if not clusters:
+        return None, None, "No refined downstream usage clusters; annotation skipped."
+
+    llm_provider = _env("LLM_PROVIDER", "gemini")
+    llm_model = _env("LLM_MODEL", "gemini-3.1-pro-preview")
+    formatter_model = _env("ANNOTATION_FORMATTER_MODEL", "gemini/gemini-3.1-pro-preview")
+    judge_model = _env("ANNOTATION_JUDGE_MODEL", "gemini/gemini-3.1-pro-preview")
+    candidate_count = int(_env("ANNOTATION_CANDIDATE_COUNT", "3"))
+
+    paper = load_paper_package(paper_dir)
+    pipeline = TwoPassAnnotationPipeline(
+        provider=llm_provider,
+        model=llm_model,
+        formatter_model=formatter_model or None,
+        judge_model=judge_model or None,
+        output_root=annotation_root,
+        annotator_id="replay_trace_builder",
+        candidate_count=max(1, candidate_count),
+        formatter_max_attempts=3,
+        include_reference_examples=True,
+        prompt_profile="full",
+    )
+    result = pipeline.run(paper)
+    return result.result, result.run_dir, None
+
+
+def _package_trace(
+    *,
+    label: str,
+    arxiv_id: str,
+    paper_input: str,
+    job_dir: Path,
+    paper_dir: Path,
+    events: list[str],
+    status: str,
+    annotation_run_dir: Path | None,
+    annotation_skipped_reason: str | None,
+    pipeline_failed_reason: str | None,
+    pipeline_stopped_reason: str | None,
+) -> Path:
+    out_dir = REPLAY_ROOT / arxiv_id
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    paper_out = out_dir / "processed_papers" / arxiv_id
+    paper_out.mkdir(parents=True, exist_ok=True)
+
+    # Core replay payloads (keep disk footprint manageable).
+    keep_files = [
+        "paper_metadata.json",
+        "usage_contexts.json",
+        "usage_context_labels.json",
+        "usage_uses_extends_verified.json",
+        "usage_citing_paragraphs.json",
+        "usage_contributions.json",
+        "usage_discovery_from_contributions.json",
+    ]
+    for name in keep_files:
+        _copy_if_exists(paper_dir / name, paper_out / name)
+
+    _copy_if_exists(job_dir / "logs", out_dir / "logs")
+    _copy_if_exists(job_dir / "summary.txt", out_dir / "summary.txt")
+    _copy_if_exists(job_dir / "run_config.json", out_dir / "run_config.json")
+    _copy_if_exists(job_dir / "input_ids.json", out_dir / "input_ids.json")
+
+    annotation_payload_path = None
+    if annotation_run_dir and annotation_run_dir.exists():
+        ann_dst = out_dir / "two_pass_outputs" / annotation_run_dir.name
+        _copy_if_exists(annotation_run_dir, ann_dst)
+        payload = ann_dst / "pass_2_ui_payload.json"
+        if payload.exists():
+            annotation_payload_path = str(payload.relative_to(out_dir))
+
+    discovery = _load_json(paper_out / "usage_discovery_from_contributions.json") or {}
+    contributions = _load_json(paper_out / "usage_contributions.json") or {}
+    payload = None
+    if annotation_payload_path:
+        payload = _load_json(out_dir / annotation_payload_path)
+
+    public_export = {
+        "citation_clusters": (discovery or {}).get("clusters") or [],
+        "target_contribution_decompositions": (payload or {}).get("claims") or [],
+    }
+    (out_dir / "scipaths_run_results.json").write_text(
+        json.dumps(public_export, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+
+    meta = {
+        "label": label,
+        "arxiv_id": arxiv_id,
+        "paper_input": paper_input,
+        "status": status,
+        "built_at": datetime.now(timezone.utc).isoformat(),
+        "source_job_dir": str(job_dir),
+        "paper_dir": str((out_dir / "processed_papers" / arxiv_id).relative_to(out_dir)),
+        "annotation_payload_path": annotation_payload_path,
+        "annotation_skipped_reason": annotation_skipped_reason,
+        "pipeline_failed_reason": pipeline_failed_reason,
+        "pipeline_stopped_reason": pipeline_stopped_reason,
+        "events": events,
+        "cluster_count": len((discovery or {}).get("clusters") or []),
+        "contribution_count": len((contributions or {}).get("contributions") or []),
+        "claim_count": len((payload or {}).get("claims") or []) if isinstance(payload, dict) else 0,
+    }
+    (out_dir / "replay_meta.json").write_text(json.dumps(meta, indent=2, ensure_ascii=False), encoding="utf-8")
+    return out_dir
+
+
+def run_one(label: str, paper_input: str) -> dict:
+    if not os.getenv("GEMINI_API_KEY"):
+        raise SystemExit("GEMINI_API_KEY is required to build replay traces.")
+
+    arxiv_id = runner_module.parse_arxiv_id(paper_input)
+    print(f"\n=== Building replay trace for {label} ({arxiv_id}) ===", flush=True)
+
+    cfg = PipelineConfig(
+        repo_root=REPO_ROOT,
+        source_root=REPO_ROOT / "src" / "processed_papers",
+        paper_input=paper_input,
+        llm_provider=_env("LLM_PROVIDER", "gemini"),
+        llm_model=_env("LLM_MODEL", "gemini-3.1-pro-preview"),
+        llm_model_step4=_env("LLM_MODEL_STEP4", "gemini-3-flash-preview"),
+        model_path="Deep-Citation/Workspace/acl_scicite_wksp_trl/best_model.pt",
+        model_data_dir="Deep-Citation/Data",
+        model_class_def="Deep-Citation/Data/class_def.json",
+        model_lm="scibert",
+        device="cpu",
+        embedding_model="sentence-transformers/all-mpnet-base-v2",
+    )
+
+    events: list[str] = []
+    artifact_path = None
+    pipeline_failed_reason = None
+    pipeline_stopped_reason = None
+    t0 = time.time()
+
+    for line, maybe_artifact in runner_module.run_pipeline(cfg, WORK_ROOT):
+        if line:
+            print(line, flush=True)
+            events.append(line)
+            if line.startswith("Pipeline stopped:"):
+                pipeline_stopped_reason = line
+            if "failed" in line.lower():
+                pipeline_failed_reason = line
+        if maybe_artifact:
+            artifact_path = maybe_artifact
+
+    if not artifact_path:
+        raise RuntimeError(f"Pipeline produced no artifact for {arxiv_id}")
+
+    job_dir = Path(str(artifact_path)).with_suffix("")
+    paper_dir = job_dir / "processed_papers" / arxiv_id
+    annotation_run_dir = None
+    annotation_skipped_reason = None
+
+    if pipeline_failed_reason:
+        status = "Failed"
+        annotation_skipped_reason = f"{pipeline_failed_reason} Annotation was not run."
+    elif pipeline_stopped_reason:
+        status = "Stopped"
+        annotation_skipped_reason = f"{pipeline_stopped_reason} Annotation was not run."
+    else:
+        print("[annotation] starting", flush=True)
+        try:
+            _run_output, annotation_run_dir, skip = _run_annotation(
+                paper_dir=paper_dir,
+                annotation_root=job_dir / "two_pass_outputs",
+            )
+            if skip:
+                annotation_skipped_reason = skip
+                status = "Completed"
+                print(f"[annotation] skipped: {skip}", flush=True)
+            else:
+                status = "Completed"
+                events.append(f"[annotation] complete: {annotation_run_dir}")
+                print(f"[annotation] complete: {annotation_run_dir}", flush=True)
+        except Exception as exc:
+            status = "Failed"
+            pipeline_failed_reason = f"Annotation failed: {exc}"
+            annotation_skipped_reason = pipeline_failed_reason
+            events.append(pipeline_failed_reason)
+            print(pipeline_failed_reason, flush=True)
+
+    out_dir = _package_trace(
+        label=label,
+        arxiv_id=arxiv_id,
+        paper_input=paper_input,
+        job_dir=job_dir,
+        paper_dir=paper_dir,
+        events=events,
+        status=status,
+        annotation_run_dir=annotation_run_dir,
+        annotation_skipped_reason=annotation_skipped_reason,
+        pipeline_failed_reason=pipeline_failed_reason,
+        pipeline_stopped_reason=pipeline_stopped_reason,
+    )
+    elapsed = time.time() - t0
+    print(f"Saved replay trace -> {out_dir} ({status}, {elapsed/60:.1f} min)", flush=True)
+    return {
+        "label": label,
+        "arxiv_id": arxiv_id,
+        "status": status,
+        "trace_dir": str(out_dir),
+        "elapsed_sec": elapsed,
+        "annotation_skipped_reason": annotation_skipped_reason,
+        "pipeline_failed_reason": pipeline_failed_reason,
+        "pipeline_stopped_reason": pipeline_stopped_reason,
+    }
+
+
+def main() -> int:
+    REPLAY_ROOT.mkdir(parents=True, exist_ok=True)
+    WORK_ROOT.mkdir(parents=True, exist_ok=True)
+
+    results = []
+    for label, paper_input in EXAMPLES.items():
+        results.append(run_one(label, paper_input))
+
+    index = {
+        "built_at": datetime.now(timezone.utc).isoformat(),
+        "examples": results,
+    }
+    index_path = REPLAY_ROOT / "index.json"
+    index_path.write_text(json.dumps(index, indent=2, ensure_ascii=False), encoding="utf-8")
+    print(f"\nWrote index -> {index_path}", flush=True)
+    for item in results:
+        print(f"- {item['arxiv_id']}: {item['status']} -> {item['trace_dir']}", flush=True)
+    return 0 if all(item["status"] == "Completed" for item in results) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hf_space/neo4j_workflow.py

@@ -0,0 +1,150 @@
+"""Neo4j sync for SciPaths workflow graph animation."""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+_DRIVER = None
+
+NEO4J_URI = os.getenv("NEO4J_URI", "bolt://localhost:7687")
+NEO4J_USER = os.getenv("NEO4J_USER", "neo4j")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD", "graphscout123")
+
+
+def neo4j_available() -> bool:
+    try:
+        driver = get_driver()
+        if driver is None:
+            return False
+        driver.verify_connectivity()
+        return True
+    except Exception:
+        return False
+
+
+def get_driver():
+    global _DRIVER
+    if _DRIVER is not None:
+        return _DRIVER
+    try:
+        from neo4j import GraphDatabase
+    except ImportError:
+        return None
+    try:
+        _DRIVER = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
+        _DRIVER.verify_connectivity()
+        return _DRIVER
+    except Exception:
+        _DRIVER = None
+        return None
+
+
+def reset_run(run_id: str) -> bool:
+    driver = get_driver()
+    if driver is None or not run_id:
+        return False
+    try:
+        with driver.session() as session:
+            session.run(
+                "MATCH (n:SciPathsNode {run_id: $run_id}) DETACH DELETE n",
+                run_id=run_id,
+            )
+        return True
+    except Exception:
+        return False
+
+
+def upsert_graph(run_id: str, nodes: list[dict[str, Any]], edges: list[dict[str, Any]]) -> bool:
+    """Replace the run's graph snapshot with the current cumulative nodes/edges."""
+    driver = get_driver()
+    if driver is None or not run_id:
+        return False
+    try:
+        with driver.session() as session:
+            session.execute_write(_upsert_tx, run_id, nodes, edges)
+        return True
+    except Exception:
+        return False
+
+
+def _upsert_tx(tx, run_id: str, nodes: list[dict[str, Any]], edges: list[dict[str, Any]]) -> None:
+    tx.run("MATCH (n:SciPathsNode {run_id: $run_id}) DETACH DELETE n", run_id=run_id)
+    for node in nodes:
+        tx.run(
+            """
+            CREATE (n:SciPathsNode {
+              run_id: $run_id,
+              id: $id,
+              kind: $kind,
+              label: $label,
+              title: $title,
+              detail: $detail,
+              step_added: $step_added,
+              pulse: $pulse,
+              color: $color,
+              size: $size
+            })
+            """,
+            run_id=run_id,
+            id=str(node.get("id") or ""),
+            kind=str(node.get("kind") or "node"),
+            label=str(node.get("label") or ""),
+            title=str(node.get("title") or node.get("label") or ""),
+            detail=str(node.get("detail") or ""),
+            step_added=int(node.get("step_added") or 0),
+            pulse=bool(node.get("pulse")),
+            color=str(node.get("color") or "#6a7a74"),
+            size=int(node.get("size") or 16),
+        )
+    for edge in edges:
+        tx.run(
+            """
+            MATCH (a:SciPathsNode {run_id: $run_id, id: $source})
+            MATCH (b:SciPathsNode {run_id: $run_id, id: $target})
+            CREATE (a)-[:SCI_REL {
+              run_id: $run_id,
+              id: $id,
+              kind: $kind,
+              pulse: $pulse,
+              muted: $muted
+            }]->(b)
+            """,
+            run_id=run_id,
+            source=str(edge.get("source") or ""),
+            target=str(edge.get("target") or ""),
+            id=str(edge.get("id") or ""),
+            kind=str(edge.get("kind") or "rel"),
+            pulse=bool(edge.get("pulse")),
+            muted=bool(edge.get("muted")),
+        )
+
+
+def fetch_graph(run_id: str) -> Optional[dict[str, Any]]:
+    driver = get_driver()
+    if driver is None or not run_id:
+        return None
+    try:
+        with driver.session() as session:
+            nodes = session.run(
+                """
+                MATCH (n:SciPathsNode {run_id: $run_id})
+                RETURN n.id AS id, n.kind AS kind, n.label AS label, n.title AS title,
+                       n.detail AS detail, n.step_added AS step_added, n.pulse AS pulse,
+                       n.color AS color, n.size AS size
+                """,
+                run_id=run_id,
+            ).data()
+            edges = session.run(
+                """
+                MATCH (a:SciPathsNode {run_id: $run_id})-[r:SCI_REL]->(b:SciPathsNode {run_id: $run_id})
+                RETURN r.id AS id, a.id AS source, b.id AS target, r.kind AS kind,
+                       r.pulse AS pulse, r.muted AS muted
+                """,
+                run_id=run_id,
+            ).data()
+        if not nodes:
+            return None
+        return {"nodes": nodes, "edges": edges}
+    except Exception:
+        return None

hf_space/replay.py

@@ -0,0 +1,130 @@
+"""Load precomputed demo traces for Streamlit replay mode."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+REPLAY_ROOT = REPO_ROOT / "replay_traces"
+
+
+def _load_json(path: Path) -> Any | None:
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def parse_arxiv_id(paper_input: str) -> str | None:
+    s = (paper_input or "").strip()
+    if not s:
+        return None
+    if "arxiv.org" in s:
+        m = re.search(r"arxiv\.org/(abs|pdf)/([^/?#]+)", s)
+        if not m:
+            return None
+        s = m.group(2)
+    s = s.replace(".pdf", "")
+    s = re.sub(r"v\d+$", "", s)
+    if not re.match(r"^[0-9]{4}\.[0-9]{4,5}$", s):
+        return None
+    return s
+
+
+def load_index() -> dict:
+    data = _load_json(REPLAY_ROOT / "index.json")
+    return data if isinstance(data, dict) else {"examples": []}
+
+
+def list_replay_examples() -> list[dict]:
+    examples = load_index().get("examples") or []
+    out = []
+    for item in examples:
+        if not isinstance(item, dict):
+            continue
+        arxiv_id = item.get("arxiv_id")
+        if not arxiv_id:
+            continue
+        meta_path = REPLAY_ROOT / str(arxiv_id) / "replay_meta.json"
+        if not meta_path.exists():
+            continue
+        out.append(item)
+    return out
+
+
+def find_trace_dir(paper_input: str) -> Optional[Path]:
+    arxiv_id = parse_arxiv_id(paper_input)
+    if not arxiv_id:
+        return None
+    trace_dir = REPLAY_ROOT / arxiv_id
+    if (trace_dir / "replay_meta.json").exists():
+        return trace_dir
+    return None
+
+
+def load_trace(paper_input: str) -> Optional[dict]:
+    """Return a session-ready payload for a saved demo trace, or None."""
+    trace_dir = find_trace_dir(paper_input)
+    if trace_dir is None:
+        return None
+
+    meta = _load_json(trace_dir / "replay_meta.json")
+    if not isinstance(meta, dict):
+        return None
+
+    paper_rel = meta.get("paper_dir") or f"processed_papers/{meta.get('arxiv_id')}"
+    paper_dir = (trace_dir / paper_rel).resolve()
+    if not paper_dir.exists():
+        return None
+
+    payload_rel = meta.get("annotation_payload_path")
+    payload_path = (trace_dir / payload_rel).resolve() if payload_rel else None
+    if payload_path and not payload_path.exists():
+        payload_path = None
+
+    events = []
+    for line in meta.get("events") or []:
+        text = str(line).strip()
+        if not text:
+            continue
+        # Normalize absolute annotation paths for display.
+        if text.startswith("[annotation] complete:"):
+            events.append("Step 8 complete")
+            events.append("Pipeline completed successfully.")
+            continue
+        if text == "Pipeline completed successfully.":
+            # Keep a single completion marker after annotation normalization.
+            if events and events[-1] == "Pipeline completed successfully.":
+                continue
+        events.append(text)
+
+    # Ensure a readable end marker for completed traces.
+    status = str(meta.get("status") or "Completed")
+    if status == "Completed" and "Pipeline completed successfully." not in events:
+        events.append("Pipeline completed successfully.")
+
+    return {
+        "label": meta.get("label") or meta.get("arxiv_id"),
+        "arxiv_id": meta.get("arxiv_id"),
+        "paper_input": meta.get("paper_input") or f"https://arxiv.org/abs/{meta.get('arxiv_id')}",
+        "status": status,
+        "run_status": status,
+        "run_events": events,
+        "run_logs": list(events),
+        "run_dir_path": str(trace_dir),
+        "paper_dir_path": str(paper_dir),
+        "annotation_payload_path": str(payload_path) if payload_path else None,
+        "annotation_skipped_reason": meta.get("annotation_skipped_reason"),
+        "pipeline_failed_reason": meta.get("pipeline_failed_reason"),
+        "pipeline_stopped_reason": meta.get("pipeline_stopped_reason"),
+        "artifact_path": str(trace_dir / "summary.txt") if (trace_dir / "summary.txt").exists() else None,
+        "remote_artifact_ref": "",
+        "replay_mode": True,
+        "cluster_count": meta.get("cluster_count"),
+        "claim_count": meta.get("claim_count"),
+    }

hf_space/requirements.txt

@@ -0,0 +1,28 @@
+streamlit>=1.36.0
+arxiv==2.2.0
+requests==2.32.5
+google-generativeai
+litellm
+rapidfuzz
+bibtexparser
+sentence-transformers
+# SciPath Live Run (parametric / websearch_deep CodeAgent)
+smolagents
+ddgs
+playwright
+PyPDF2
+python-dotenv
+openai
+# Pin stack for Deep-Citation step 4 on macOS x86_64:
+# torch 2.2.x needs numpy<2; newer torch wheels are unavailable on this platform,
+# and transformers 5.x refuses torch<2.4.
+transformers==4.46.3
+torch==2.2.2
+huggingface_hub>=0.23,<1.0
+typer
+tqdm
+pydantic
+numpy==1.26.4
+pandas
+scipy==1.11.4
+scikit-learn==1.4.2

hf_space/runner.py

@@ -0,0 +1,333 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Generator, List, Optional, Tuple
+
+
+@dataclass
+class PipelineConfig:
+    repo_root: Path
+    source_root: Path
+    paper_input: str
+    llm_provider: str
+    llm_model: str
+    llm_model_step4: str
+    model_path: str
+    model_data_dir: str
+    model_class_def: str
+    model_lm: str
+    device: str
+    embedding_model: str
+
+
+@dataclass
+class PipelineResult:
+    job_id: str
+    job_dir: Path
+    paper_dir: Path
+    zip_path: Path
+
+
+STEP_LABELS = {
+    1: "Fetch metadata + LaTeX for input paper",
+    2: "Add citation markers",
+    3: "Build usage contexts",
+    4: "Label citation functions",
+    5: "Verify USES/EXTENDS",
+    6: "Extract arXiv paragraphs",
+    7: "Extract target contributions and refine clusters",
+}
+
+FULL_STEPS = [1, 2, 3, 4, 5, 6, 7]
+STOP_PREFIX = "Pipeline stopped:"
+
+
+def parse_arxiv_id(paper_input: str) -> str:
+    s = (paper_input or "").strip()
+    if not s:
+        raise ValueError("paper_input is required")
+    if "arxiv.org" in s:
+        m = re.search(r"arxiv\.org/(abs|pdf)/([^/?#]+)", s)
+        if not m:
+            raise ValueError(f"Could not parse arXiv ID from URL: {s}")
+        s = m.group(2)
+    s = s.replace(".pdf", "")
+    s = re.sub(r"v\d+$", "", s)
+    if not re.match(r"^[0-9]{4}\.[0-9]{4,5}$", s):
+        raise ValueError(f"Invalid arXiv ID format: {s}")
+    return s
+
+
+def _build_commands(
+    cfg: PipelineConfig,
+    step: int,
+    job_processed_root: Path,
+    paper_id: str,
+    ids_path: Optional[Path],
+) -> List[List[str]]:
+    py = sys.executable
+    if step == 1:
+        assert ids_path is not None
+        return [[
+            py,
+            "src/step_01_fetch/fetch_metadata.py",
+            "--ids",
+            str(ids_path),
+            "--outdir",
+            str(job_processed_root),
+        ]]
+    if step == 2:
+        return [[py, "src/step_02_mark_citations/replace_citation_markers.py", "--root", str(job_processed_root)]]
+    if step == 3:
+        return [[py, "src/step_03_usage_contexts/build_usage_contexts.py", "--root", str(job_processed_root), "--out-name", "usage_contexts.json"]]
+    if step == 4:
+        return [[
+            py,
+            "src/step_04_label_citations/label_citation_functions.py",
+            "--root",
+            str(job_processed_root),
+            "--model-path",
+            cfg.model_path,
+            "--model-data-dir",
+            cfg.model_data_dir,
+            "--model-class-def",
+            cfg.model_class_def,
+            "--model-lm",
+            cfg.model_lm,
+            "--device",
+            cfg.device,
+        ]]
+    if step == 5:
+        return [[
+            py,
+            "src/step_05_verify_uses_extends/verify_uses_extends.py",
+            "--root",
+            str(job_processed_root),
+            "--k",
+            "0",
+            "--batch-size",
+            "25",
+        ]]
+    if step == 6:
+        return [[py, "src/step_06_extract_paragraphs/extract_arxiv_paragraphs.py", "--root", str(job_processed_root)]]
+    if step == 7:
+        return [
+            [py, "src/step_07_extract_and_refine/extract_contributions_from_citations.py", "--root", str(job_processed_root)],
+            [py, "src/step_07_extract_and_refine/refine_and_filter_clusters_llm.py", "--root", str(job_processed_root), "--inplace", "--overwrite"],
+        ]
+    raise ValueError(f"Unknown step: {step}")
+
+
+def _write_single_id_file(job_dir: Path, arxiv_id: str) -> Path:
+    ids_path = job_dir / "input_ids.json"
+    payload = [{"id": arxiv_id, "title": "", "id_type": "ArXiv"}]
+    ids_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    return ids_path
+
+
+def _write_run_metadata(cfg: PipelineConfig, job_dir: Path, paper_id: str, arxiv_id: str) -> None:
+    payload = {
+        "paper_input": cfg.paper_input,
+        "paper_id": paper_id,
+        "arxiv_id": arxiv_id,
+        "source_root": str(cfg.source_root),
+        "steps": FULL_STEPS + ["annotation"],
+        "llm_provider": cfg.llm_provider,
+        "llm_model": cfg.llm_model,
+        "llm_model_step4": cfg.llm_model_step4,
+        "device": cfg.device,
+        "embedding_model": cfg.embedding_model,
+        "timestamp": int(time.time()),
+    }
+    (job_dir / "run_config.json").write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def _zip_job_dir(job_dir: Path) -> Path:
+    zip_base = job_dir.parent / job_dir.name
+    archive = shutil.make_archive(str(zip_base), "zip", root_dir=str(job_dir))
+    return Path(archive)
+
+
+def _tail_log(path: Path, max_lines: int = 60) -> str:
+    try:
+        lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
+    except Exception:
+        return ""
+    if not lines:
+        return ""
+    return "\n".join(lines[-max_lines:])
+
+
+def _load_json(path: Path, default=None):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def _write_summary_and_zip(job_dir: Path, summary_lines: List[str]) -> Path:
+    (job_dir / "summary.txt").write_text("\n".join(summary_lines), encoding="utf-8")
+    return _zip_job_dir(job_dir)
+
+
+def _count_verified_uses_extends(payload: dict) -> int:
+    records = payload.get("confirmed") or payload.get("verified_contexts") or payload.get("contexts") or payload.get("items") or []
+    if not isinstance(records, list):
+        return 0
+    accepted = {"USES", "EXTENDS", "Uses", "Extends"}
+    return sum(1 for item in records if isinstance(item, dict) and item.get("label") in accepted)
+
+
+def _stop_reason_after_step(step: int, paper_dir: Path) -> str | None:
+    if step == 1:
+        if not paper_dir.exists():
+            return "metadata could not be fetched for this paper"
+        if not (paper_dir / "processed_main.tex").exists():
+            return "arXiv source could not be retrieved or converted for this paper"
+        citations = _load_json(paper_dir / "citations_metadata.json", [])
+        if not isinstance(citations, list) or not citations:
+            return "Semantic Scholar returned no citing papers for this target paper"
+
+    if step == 3:
+        usage = _load_json(paper_dir / "usage_contexts.json", {})
+        if not isinstance(usage, dict):
+            return "citation usage contexts could not be built"
+        if int(usage.get("num_contexts") or 0) == 0:
+            return "no citation usage contexts were found"
+
+    if step == 4:
+        labels = _load_json(paper_dir / "usage_context_labels.json", {})
+        contexts = labels.get("labels") if isinstance(labels, dict) else None
+        if not isinstance(contexts, list) or not contexts:
+            return "citation-function labeling produced no labeled contexts"
+
+    if step == 5:
+        verified = _load_json(paper_dir / "usage_uses_extends_verified.json", {})
+        if not isinstance(verified, dict):
+            return "USES/EXTENDS verification did not produce an output file"
+        if _count_verified_uses_extends(verified) == 0:
+            return "no downstream citations were verified as USES or EXTENDS"
+
+    if step == 6:
+        paragraphs = _load_json(paper_dir / "usage_citing_paragraphs.json", {})
+        citing = paragraphs.get("citing_papers") if isinstance(paragraphs, dict) else None
+        if not isinstance(citing, list) or not citing:
+            return "no citing-paper paragraphs could be extracted from arXiv"
+        usable = [
+            item for item in citing
+            if isinstance(item, dict)
+            and not item.get("error")
+            and (item.get("matched_paragraphs") or item.get("target_citing_paragraphs"))
+        ]
+        if not usable:
+            return "arXiv paragraph extraction returned no usable citing-paper text"
+
+    if step == 7:
+        contributions = _load_json(paper_dir / "usage_contributions.json", {})
+        items = contributions.get("contributions") if isinstance(contributions, dict) else None
+        if not isinstance(items, list) or not items:
+            return "no downstream target-contribution evidence could be extracted"
+        refined = _load_json(paper_dir / "usage_discovery_from_contributions.json", {})
+        clusters = refined.get("clusters") if isinstance(refined, dict) else None
+        if not isinstance(clusters, list) or not clusters:
+            return "no valid downstream usage clusters survived refinement"
+
+    return None
+
+
+def run_pipeline(cfg: PipelineConfig, output_root: Path) -> Generator[Tuple[str, Optional[str]], None, PipelineResult]:
+    output_root.mkdir(parents=True, exist_ok=True)
+    job_id = f"job_{int(time.time())}_{uuid.uuid4().hex[:8]}"
+    job_dir = output_root / job_id
+    job_processed_root = job_dir / "processed_papers"
+    job_logs = job_dir / "logs"
+
+    job_processed_root.mkdir(parents=True, exist_ok=True)
+    job_logs.mkdir(parents=True, exist_ok=True)
+
+    arxiv_id = parse_arxiv_id(cfg.paper_input)
+    paper_id = arxiv_id
+    ids_path = _write_single_id_file(job_dir, arxiv_id)
+    _write_run_metadata(cfg, job_dir, paper_id, arxiv_id)
+
+    base_env = os.environ.copy()
+    base_env["LLM_PROVIDER"] = cfg.llm_provider
+    base_env["LLM_MODEL"] = cfg.llm_model
+
+    summary_lines: List[str] = []
+    paper_dir = job_processed_root / paper_id
+
+    max_step = 8
+    for step in FULL_STEPS:
+        label = STEP_LABELS[step]
+        log_file = job_logs / f"step_{step:02d}.log"
+        summary_lines.append(f"[{step}] {label}")
+        yield (f"Step {step}/{max_step}: {label}", None)
+
+        env = base_env.copy()
+        if step == 5 and cfg.llm_model_step4:
+            env["LLM_MODEL"] = cfg.llm_model_step4
+
+        with log_file.open("w", encoding="utf-8") as lf:
+            return_code = 0
+            failed_cmd: List[str] | None = None
+            for cmd in _build_commands(cfg, step, job_processed_root, paper_id, ids_path):
+                lf.write(f"$ {' '.join(cmd)}\n\n")
+                proc = subprocess.Popen(
+                    cmd,
+                    cwd=str(cfg.repo_root),
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.STDOUT,
+                    text=True,
+                    encoding="utf-8",
+                    errors="ignore",
+                    env=env,
+                )
+                assert proc.stdout is not None
+                for line in proc.stdout:
+                    lf.write(line)
+                return_code = proc.wait()
+                if return_code != 0:
+                    failed_cmd = cmd
+                    break
+
+        if return_code != 0:
+            summary_lines.append(f"FAILED at step {step}")
+            zip_path = _write_summary_and_zip(job_dir, summary_lines)
+            tail = _tail_log(log_file)
+            if tail:
+                yield (
+                    f"Step {step} failed.\n\nCommand: {' '.join(failed_cmd or [])}\n\nLast log lines:\n{tail}",
+                    str(zip_path),
+                )
+            else:
+                yield (f"Step {step} failed. Command: {' '.join(failed_cmd or [])}", str(zip_path))
+            return PipelineResult(job_id=job_id, job_dir=job_dir, paper_dir=paper_dir, zip_path=zip_path)
+        else:
+            yield (f"Step {step} complete", None)
+
+        if step == 1 and not paper_dir.exists():
+            summary_lines.append("FAILED: fetch_metadata did not create paper directory")
+            zip_path = _write_summary_and_zip(job_dir, summary_lines)
+            yield (f"Step 1 finished but paper dir missing: {paper_dir}", str(zip_path))
+            return PipelineResult(job_id=job_id, job_dir=job_dir, paper_dir=paper_dir, zip_path=zip_path)
+
+        stop_reason = _stop_reason_after_step(step, paper_dir)
+        if stop_reason:
+            message = f"{STOP_PREFIX} {stop_reason}."
+            summary_lines.append(message)
+            zip_path = _write_summary_and_zip(job_dir, summary_lines)
+            yield (message, str(zip_path))
+            return PipelineResult(job_id=job_id, job_dir=job_dir, paper_dir=paper_dir, zip_path=zip_path)
+
+    summary_lines.append("SUCCESS")
+    zip_path = _write_summary_and_zip(job_dir, summary_lines)
+    yield ("Pipeline completed successfully.", str(zip_path))
+    return PipelineResult(job_id=job_id, job_dir=job_dir, paper_dir=paper_dir, zip_path=zip_path)

hf_space/scipath_live/README.md

@@ -0,0 +1,38 @@
+# SciPath Live (self-contained)
+
+Minimal SciPath Task A CodeAgent used by **System Run → Live Run**.
+
+## Included methods
+
+| Method | Tools |
+|--------|--------|
+| `parametric` | `check_answer_format` |
+| `websearch_deep` | `web_search_tool`, `deep_web_search_tool`, `check_answer_format` |
+
+## Demo claim
+
+`data/example_claim.json` — one claim from AVerImaTeC (`2505.17978`, claim C1), including gold enabling contributions for Task A evaluation.
+
+## CLI
+
+From `hf_space/`:
+
+```bash
+python -m scipath_live.cli run --method parametric --output-dir runs/system_live/test
+python -m scipath_live.cli evaluate --result-json runs/system_live/test/result.json
+```
+
+## Env
+
+- `GOOGLE_GENAI_API_KEY` or `GEMINI_API_KEY` (generation + judge)
+- For `websearch_deep`: install Chromium into the demo-local cache:
+
+```bash
+# from demo_2026_07/
+export PLAYWRIGHT_BROWSERS_PATH="$(pwd)/.playwright"
+python -m playwright install chromium
+```
+
+`system_live_runner` / `tools.py` always force `PLAYWRIGHT_BROWSERS_PATH` to `demo_2026_07/.playwright` so Cursor sandbox temp paths are not used.
+
+This package does **not** depend on `dryrun/` or other repos.

hf_space/scipath_live/__init__.py

@@ -0,0 +1,19 @@
+"""Self-contained SciPath Task A CodeAgent (parametric + websearch_deep)."""
+
+from .pipeline import load_example_claim
+
+__all__ = ["load_example_claim", "run_method", "evaluate_task_a"]
+
+
+def run_method(*args, **kwargs):
+    from .pipeline import run_method as _run
+
+    return _run(*args, **kwargs)
+
+
+def evaluate_task_a(*args, **kwargs):
+    from .pipeline import evaluate_task_a as _eval
+
+    return _eval(*args, **kwargs)
+
+__all__ = ["evaluate_task_a", "load_example_claim", "run_method"]

hf_space/scipath_live/agent.py

@@ -0,0 +1,227 @@
+"""Slim SciPath CodeAgent runner (parametric + websearch_deep only)."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional
+
+from dotenv import load_dotenv
+from smolagents import CodeAgent, LiteLLMModel
+
+from .prompts import get_scipath_controller_prompt, parse_ingredients_from_answer
+from .tools import check_answer_format, deep_web_search_tool, web_search_tool
+
+GEMINI_MODEL_IDS = {
+    "gemini-2.0-flash",
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-3-flash-preview",
+    "gemini-3.1-pro-preview",
+    "gemini-3.5-flash",
+}
+
+
+def _memory_steps_to_list(agent: CodeAgent) -> list[dict[str, Any]]:
+    steps_list: list[dict[str, Any]] = []
+    for i, step in enumerate(getattr(agent.memory, "steps", []) or []):
+        item: dict[str, Any] = {
+            "step_type": type(step).__name__,
+            "step_index": i,
+            "timestamp": datetime.now().isoformat(),
+        }
+        for attr in ("step_number", "task", "code_action", "observations", "model_output"):
+            if hasattr(step, attr):
+                value = getattr(step, attr)
+                item[attr] = str(value) if value is not None and not isinstance(value, (str, int, float, bool, list, dict)) else value
+        if getattr(step, "error", None):
+            item["error"] = str(step.error)
+        steps_list.append(item)
+    return steps_list
+
+
+def _clip(text: Any, limit: int = 1200) -> str:
+    s = str(text or "").strip()
+    if len(s) <= limit:
+        return s
+    return s[: limit - 1] + "…"
+
+
+def format_agent_trace(steps: list[dict[str, Any]]) -> list[str]:
+    """Human-readable SciFy CodeAgent step trace for the Live Run terminal."""
+    lines: list[str] = []
+    lines.append("=== SciFy CodeAgent trace ===")
+    action_steps = [s for s in steps if s.get("step_type") == "ActionStep"]
+    if not action_steps:
+        lines.append("(no action steps recorded)")
+        return lines
+
+    for step in action_steps:
+        n = step.get("step_number")
+        if n is None:
+            n = int(step.get("step_index") or 0) + 1
+        lines.append("")
+        lines.append(f"── Step {n} ──")
+        thought = _clip(step.get("model_output"), 1600)
+        if thought:
+            lines.append("Thought / model output:")
+            lines.extend(thought.splitlines())
+        code = _clip(step.get("code_action"), 1600)
+        if code:
+            lines.append("Code action:")
+            lines.extend(code.splitlines())
+        obs = _clip(step.get("observations"), 1200)
+        if obs:
+            lines.append("Observations:")
+            lines.extend(obs.splitlines())
+        err = _clip(step.get("error"), 600)
+        if err:
+            lines.append(f"Error: {err}")
+    lines.append("")
+    lines.append("=== end trace ===")
+    return lines
+
+
+def _print_trace(steps: list[dict[str, Any]]) -> None:
+    for line in format_agent_trace(steps):
+        print(line, flush=True)
+
+
+def _ensure_api_keys() -> None:
+    load_dotenv()
+    google = (
+        os.getenv("GOOGLE_GENAI_API_KEY")
+        or os.getenv("GEMINI_API_KEY")
+        or os.getenv("GOOGLE_API_KEY")
+        or ""
+    ).strip()
+    if google:
+        os.environ.setdefault("GEMINI_API_KEY", google)
+        os.environ.setdefault("GOOGLE_API_KEY", google)
+        os.environ.setdefault("GOOGLE_GENAI_API_KEY", google)
+
+
+def run_agent(
+    query: str,
+    *,
+    model_name: str = "gemini-3-flash-preview",
+    method: str = "parametric",
+    max_steps: int = 40,
+) -> tuple[Any, list[dict[str, Any]]]:
+    """Run SciPath Task A CodeAgent for one claim."""
+    if method not in {"parametric", "websearch_deep"}:
+        raise ValueError(f"Unsupported method for demo live run: {method}")
+
+    _ensure_api_keys()
+    litellm_model_id = (
+        f"gemini/{model_name}" if model_name in GEMINI_MODEL_IDS else model_name
+    )
+    model = LiteLLMModel(
+        model_id=litellm_model_id,
+        temperature=0.1,
+        max_tokens=16384,
+        timeout=2400,
+    )
+
+    if method == "parametric":
+        tool_list = [check_answer_format]
+    else:
+        tool_list = [web_search_tool, deep_web_search_tool, check_answer_format]
+
+    agent = CodeAgent(
+        tools=tool_list,
+        model=model,
+        verbosity_level=2,
+        additional_authorized_imports=["json", "os", "typing", "pprint"],
+        max_steps=max_steps,
+        executor_kwargs={"timeout_seconds": None},
+    )
+    prompt = get_scipath_controller_prompt(query, method)
+    result = agent.run(prompt)
+    logs = _memory_steps_to_list(agent)
+    return result, logs
+
+
+def run_claim_to_dir(
+    *,
+    claim: str,
+    paper_id: str,
+    claim_idx: int,
+    paper_title: str,
+    method: str,
+    output_dir: Path,
+    model_name: str = "gemini-3-flash-preview",
+) -> dict[str, Any]:
+    """Run one claim and write answers.jsonl + logs.jsonl into output_dir."""
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    problem_id = f"{paper_id}__claim{claim_idx}"
+    claim_row = {
+        "type": "problem",
+        "format_version": "1.0",
+        "problem_id": problem_id,
+        "problem_version": "1.0",
+        "domain": "ai",
+        "subdomain": "scipath",
+        "claim": claim,
+    }
+    index_row = {
+        "problem_id": problem_id,
+        "paper_id": paper_id,
+        "claim_idx": claim_idx,
+        "paper_title": paper_title,
+        "claim": claim,
+        "split": "dev",
+    }
+    (output_dir / "claim.jsonl").write_text(
+        json.dumps(claim_row, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    (output_dir / "task_index.jsonl").write_text(
+        json.dumps(index_row, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+
+    print(f"[scipath_live] Starting CodeAgent method={method} model={model_name}", flush=True)
+    print(f"[scipath_live] Claim: {claim}", flush=True)
+    t0 = time.time()
+    answer, logs = run_agent(claim, model_name=model_name, method=method)
+    wall = time.time() - t0
+    print(f"[scipath_live] Agent finished in {wall:.1f}s ({len(logs)} memory steps)", flush=True)
+    _print_trace(logs)
+
+    ingredients = parse_ingredients_from_answer(answer)
+    if not ingredients and isinstance(answer, dict):
+        ingredients = parse_ingredients_from_answer(answer)
+    print(f"[scipath_live] Parsed {len(ingredients)} ingredients", flush=True)
+
+    out = {
+        "type": "scipath_task_a",
+        "format_version": "1.0",
+        "problem_id": problem_id,
+        "problem_version": "1.0",
+        "team": "scify",
+        "run_id": f"live_{method}",
+        "ingredients": ingredients,
+        "raw_answer": answer if isinstance(answer, (dict, list, str)) else str(answer),
+        "wall_clock_time": wall,
+        "method": method,
+        "model_name": model_name,
+        "paper_id": paper_id,
+        "claim_idx": claim_idx,
+        "paper_title": paper_title,
+        "claim": claim,
+    }
+    (output_dir / "answers.jsonl").write_text(
+        json.dumps(out, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    (output_dir / "logs.jsonl").write_text(
+        json.dumps({"problem_id": problem_id, "steps": logs}, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    (output_dir / "result.json").write_text(
+        json.dumps(out, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    return out

hf_space/scipath_live/cli.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""CLI entry for SciPath Live Run (used as a subprocess from Streamlit)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Allow `python -m scipath_live.cli` and `python scipath_live/cli.py`
+PACKAGE_ROOT = Path(__file__).resolve().parent
+HF_SPACE = PACKAGE_ROOT.parent
+if str(HF_SPACE) not in sys.path:
+    sys.path.insert(0, str(HF_SPACE))
+
+from scipath_live.pipeline import evaluate_task_a, load_example_claim, run_method  # noqa: E402
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="SciPath Live Run CLI")
+    parser.add_argument(
+        "action",
+        choices=["run", "evaluate"],
+        help="run a method or evaluate an existing run result JSON",
+    )
+    parser.add_argument(
+        "--method",
+        default="parametric",
+        choices=["parametric", "websearch_deep", "codeagent_parametric", "codeagent_websearch_deep"],
+    )
+    parser.add_argument("--output-dir", default="")
+    parser.add_argument("--model", default="gemini-3-flash-preview")
+    parser.add_argument("--judge-model", default="gemini/gemini-3.1-pro-preview")
+    parser.add_argument(
+        "--result-json",
+        default="",
+        help="For evaluate: path to result.json from a prior run",
+    )
+    args = parser.parse_args()
+
+    if args.action == "run":
+        out = Path(args.output_dir) if args.output_dir else None
+        result = run_method(
+            args.method,
+            output_dir=out,
+            model_name=args.model,
+        )
+        print(json.dumps({"ok": True, "result": result}, ensure_ascii=False))
+        return 0
+
+    if not args.result_json:
+        print(json.dumps({"ok": False, "error": "--result-json is required for evaluate"}))
+        return 2
+    run_result = json.loads(Path(args.result_json).read_text(encoding="utf-8"))
+    # Ensure output_dir is set for writing judged JSON.
+    if not run_result.get("output_dir"):
+        run_result["output_dir"] = str(Path(args.result_json).parent)
+    judged = evaluate_task_a(
+        run_result=run_result,
+        claim_record=load_example_claim(),
+        judge_model=args.judge_model,
+    )
+    print(json.dumps({"ok": True, "judged": judged}, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

hf_space/scipath_live/data/example_claim.json

@@ -0,0 +1,124 @@
+{
+  "paper_id": "2505.17978",
+  "claim_idx": 0,
+  "claim_id": "C1",
+  "paper_title": "AVerImaTeC: A Dataset for Automatic Verification of Image-Text Claims with Evidence from the Web",
+  "claim": "Dataset: A real-world image-text claim verification dataset annotated with question-answer reasoning paths and web evidence, enabling the training and evaluation of multimodal fact-checking systems.",
+  "enabling_contributions": [
+    {
+      "enabling_contribution_id": "2505.17978::ingredient::01",
+      "enabling_contribution": "Source fact-checking articles containing multimodal claims",
+      "canonical_ref_id": "__NONE__",
+      "canonical_grounding": null,
+      "additional_ref_ids": [
+        "ref_averitec",
+        "ref_ammeba"
+      ],
+      "additional_groundings": [
+        {
+          "ref_id": "ref_averitec",
+          "bib_key": "",
+          "paper_id": "",
+          "external_ids": {},
+          "ref_title": "AVeriTeC: A Dataset for Real-world Claim Verification with Evidence from the Web",
+          "ref_year": "",
+          "ref_authors": ""
+        },
+        {
+          "ref_id": "ref_ammeba",
+          "bib_key": "",
+          "paper_id": "",
+          "external_ids": {},
+          "ref_title": "AMMeBa: A Large-Scale Survey and Dataset of Media-Based Misinformation In-The-Wild",
+          "ref_year": "",
+          "ref_authors": ""
+        }
+      ],
+      "canonical_annotation": {
+        "role": "DATA_SOURCE",
+        "roles": [
+          "DATA_SOURCE"
+        ],
+        "contribution": "Provides the raw real-world image-text claims that are normalized and annotated to form the dataset.",
+        "rationale": "The dataset is a composite of claims extracted from multiple prior fact-checking resources. No single prior study fully represents this substrate, making NONE the correct canonical grounding, with the primary sources listed as additional groundings.",
+        "evidence_span": "we incorporated partially annotated articles from three sources: 1) filtered articles from AVeriTec... 2) articles verifying image-related claims from AMMEBA"
+      }
+    },
+    {
+      "enabling_contribution_id": "2505.17978::ingredient::02",
+      "enabling_contribution": "Question-answering representation for verification rationale",
+      "canonical_ref_id": "ref_complex",
+      "canonical_grounding": {
+        "ref_id": "ref_complex",
+        "bib_key": "",
+        "paper_id": "",
+        "external_ids": {},
+        "ref_title": "Complex Claim Verification with Evidence Retrieved in the Wild",
+        "ref_year": "",
+        "ref_authors": ""
+      },
+      "additional_ref_ids": [],
+      "additional_groundings": [],
+      "canonical_annotation": {
+        "role": "CONCEPTUAL_FRAMEWORK",
+        "roles": [
+          "CONCEPTUAL_FRAMEWORK"
+        ],
+        "contribution": "Provides the QA-based reasoning representation used to structure the evidence retrieval and verification process.",
+        "rationale": "The paper explicitly adopts QA as the reasoning representation for fact-checking, citing prior work that established this paradigm. Chen et al. (CLAIMDECOMP) is a clean representative for QA-based claim decomposition.",
+        "evidence_span": "To capture the rationale in claim verification, a complex reasoning task, various reasoning representations have been explored... and QA"
+      }
+    },
+    {
+      "enabling_contribution_id": "2505.17978::ingredient::03",
+      "enabling_contribution": "Four-way veracity labeling schema",
+      "canonical_ref_id": "ref_averitec",
+      "canonical_grounding": {
+        "ref_id": "ref_averitec",
+        "bib_key": "",
+        "paper_id": "",
+        "external_ids": {},
+        "ref_title": "AVeriTeC: A Dataset for Real-world Claim Verification with Evidence from the Web",
+        "ref_year": "",
+        "ref_authors": ""
+      },
+      "additional_ref_ids": [],
+      "additional_groundings": [],
+      "canonical_annotation": {
+        "role": "CONCEPTUAL_FRAMEWORK",
+        "roles": [
+          "CONCEPTUAL_FRAMEWORK"
+        ],
+        "contribution": "Provides the specific four-way label space (supported, refuted, not enough evidence, conflicting) used to annotate the claims.",
+        "rationale": "The paper explicitly adopts the exact four-way veracity labeling schema introduced in AVeriTeC.",
+        "evidence_span": "We follow the four-way veracity labeling schema from [Schlichtkrull et al., 2023]: supported, refuted, not enough evidence, and conflicting/cherry-picking."
+      }
+    },
+    {
+      "enabling_contribution_id": "2505.17978::ingredient::04",
+      "enabling_contribution": "Multi-stage annotation pipeline with evidence sufficiency checks",
+      "canonical_ref_id": "ref_averitec",
+      "canonical_grounding": {
+        "ref_id": "ref_averitec",
+        "bib_key": "",
+        "paper_id": "",
+        "external_ids": {},
+        "ref_title": "AVeriTeC: A Dataset for Real-world Claim Verification with Evidence from the Web",
+        "ref_year": "",
+        "ref_authors": ""
+      },
+      "additional_ref_ids": [],
+      "additional_groundings": [],
+      "canonical_annotation": {
+        "role": "EVALUATION_PROTOCOL",
+        "roles": [
+          "EVALUATION_PROTOCOL"
+        ],
+        "contribution": "Provides the foundational multi-stage annotation and verification workflow that the paper extends for image-text claims.",
+        "rationale": "The paper explicitly states that its annotation pipeline is an extension of the process proposed in AVeriTeC, making it the canonical grounding for this workflow.",
+        "evidence_span": "extending the annotation process proposed in [Schlichtkrull et al., 2023] to the domain of image-text claims."
+      }
+    }
+  ],
+  "source": "AVerImaTeC"
+}

hf_space/scipath_live/judge.py

@@ -0,0 +1,305 @@
+"""Task A ingredient matching judge (demo-local, single-claim)."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+from typing import Any
+
+import litellm
+from dotenv import load_dotenv
+
+MATCHING_JUDGE_PROMPT = """\
+You are evaluating whether predicted enabling contributions match reference enabling contributions for a scientific discovery.
+
+A full match requires that the predicted item express the same functional requirement needed to realize the discovery. It may use different wording, but it must preserve the key resource, method, process, role, and level of specificity.
+
+A partial match means the predicted item is related but too broad, too narrow, missing an important role/detail, or merges multiple distinct reference requirements.
+
+Do not mark broad umbrella items as full matches for multiple distinct reference contributions.
+
+Discovery claim:
+{claim}
+
+Reference enabling contributions:
+{references}
+
+Predicted enabling contributions:
+{predicted}
+
+Return candidate matches only where match is "full" or "partial". Omit unrelated pairs.
+
+Respond with JSON only (no markdown):
+{{"matches": [{{"reference_idx": <1-based index>, "predicted_idx": <1-based index>, "match": "full"|"partial", "reasoning": "<one sentence>"}}]}}\
+"""
+
+
+def _format_reference_ingredient(silver_ingredient: dict) -> str:
+    annotation = silver_ingredient.get("canonical_annotation") or {}
+    roles = annotation.get("roles")
+    if isinstance(roles, list):
+        role_text = ", ".join(str(r) for r in roles)
+    else:
+        role_text = annotation.get("role", "") or silver_ingredient.get("role", "")
+
+    ingredient = (
+        silver_ingredient.get("enabling_contribution")
+        or silver_ingredient.get("ingredient")
+        or silver_ingredient.get("description")
+        or ""
+    )
+    lines = [f"Ingredient: {ingredient}"]
+    if role_text:
+        lines.append(f"Role: {role_text}")
+    if annotation.get("contribution"):
+        lines.append(f"Contribution: {annotation['contribution']}")
+    if annotation.get("rationale"):
+        lines.append(f"Rationale: {annotation['rationale']}")
+    return "\n".join(lines)
+
+
+def _format_predicted_ingredient(idx: int, ingredient: dict) -> str:
+    lines = [f"[{idx}] {ingredient.get('description', '')}"]
+    if ingredient.get("role"):
+        lines.append(f"    Role: {ingredient['role']}")
+    if ingredient.get("rationale"):
+        lines.append(f"    Rationale: {ingredient['rationale']}")
+    return "\n".join(lines)
+
+
+def _parse_matching_judgment(raw: str, n_references: int, n_predicted: int) -> dict | None:
+    raw = re.sub(r"^```(?:json)?\s*", "", raw.strip())
+    raw = re.sub(r"\s*```$", "", raw)
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    raw_matches = data.get("matches")
+    if not isinstance(raw_matches, list):
+        return None
+    matches = []
+    for match in raw_matches:
+        if not isinstance(match, dict):
+            continue
+        ref_idx = match.get("reference_idx")
+        pred_idx = match.get("predicted_idx")
+        label = str(match.get("match", "")).lower()
+        if label not in {"full", "partial"}:
+            continue
+        if not isinstance(ref_idx, int) or not isinstance(pred_idx, int):
+            continue
+        if not (1 <= ref_idx <= n_references and 1 <= pred_idx <= n_predicted):
+            continue
+        matches.append(
+            {
+                "reference_idx": ref_idx,
+                "predicted_idx": pred_idx,
+                "match": label,
+                "reasoning": str(match.get("reasoning", "")),
+            }
+        )
+    return {"matches": matches}
+
+
+def maximum_full_matching(
+    matches: list[dict], n_references: int, n_predicted: int
+) -> list[dict]:
+    edges: dict[int, list[dict]] = {i: [] for i in range(1, n_references + 1)}
+    seen: set[tuple[int, int]] = set()
+    for match in matches:
+        if match.get("match") != "full":
+            continue
+        ref_idx = match.get("reference_idx")
+        pred_idx = match.get("predicted_idx")
+        if not isinstance(ref_idx, int) or not isinstance(pred_idx, int):
+            continue
+        if not (1 <= ref_idx <= n_references and 1 <= pred_idx <= n_predicted):
+            continue
+        key = (ref_idx, pred_idx)
+        if key in seen:
+            continue
+        seen.add(key)
+        edges[ref_idx].append(match)
+    for ref_edges in edges.values():
+        ref_edges.sort(key=lambda m: m["predicted_idx"])
+
+    pred_to_match: dict[int, dict] = {}
+
+    def _try_match(ref_idx: int, visited: set[int]) -> bool:
+        for edge in edges.get(ref_idx, []):
+            pred_idx = edge["predicted_idx"]
+            if pred_idx in visited:
+                continue
+            visited.add(pred_idx)
+            previous = pred_to_match.get(pred_idx)
+            if previous is None or _try_match(previous["reference_idx"], visited):
+                pred_to_match[pred_idx] = edge
+                return True
+        return False
+
+    for ref_idx in range(1, n_references + 1):
+        _try_match(ref_idx, set())
+    return sorted(
+        pred_to_match.values(), key=lambda m: (m["reference_idx"], m["predicted_idx"])
+    )
+
+
+async def judge_ingredient_matching(
+    model: str,
+    claim: str,
+    reference_ingredients: list[dict],
+    predicted_ingredients: list[dict],
+    max_retries: int = 3,
+) -> dict:
+    references_text = "\n\n".join(
+        f"[{i + 1}] " + _format_reference_ingredient(ing).replace("\n", "\n    ")
+        for i, ing in enumerate(reference_ingredients)
+    ) or "(none)"
+    predicted_text = "\n\n".join(
+        _format_predicted_ingredient(i + 1, ing)
+        for i, ing in enumerate(predicted_ingredients)
+    ) or "(none)"
+    prompt = MATCHING_JUDGE_PROMPT.format(
+        claim=claim, references=references_text, predicted=predicted_text
+    )
+    for _ in range(max_retries):
+        msg = await litellm.acompletion(
+            model=model,
+            max_tokens=8192,
+            messages=[{"role": "user", "content": prompt}],
+        )
+        raw = msg.choices[0].message.content.strip()
+        result = _parse_matching_judgment(
+            raw, len(reference_ingredients), len(predicted_ingredients)
+        )
+        if result is not None:
+            return result
+    raise ValueError("Failed to parse valid matching judgment")
+
+
+def _gold_to_ui_ingredients(gold: list[dict]) -> list[dict[str, str]]:
+    out = []
+    for g in gold:
+        ann = g.get("canonical_annotation") or {}
+        role = ""
+        if isinstance(ann.get("roles"), list) and ann["roles"]:
+            role = str(ann["roles"][0])
+        else:
+            role = str(ann.get("role") or g.get("role") or "")
+        out.append(
+            {
+                "description": str(
+                    g.get("enabling_contribution") or g.get("description") or ""
+                ),
+                "role": role,
+            }
+        )
+    return out
+
+
+def evaluate_prediction(
+    *,
+    claim: str,
+    gold_ingredients: list[dict],
+    predicted_ingredients: list[dict],
+    judge_model: str = "gemini/gemini-3.1-pro-preview",
+) -> dict[str, Any]:
+    """Sync wrapper: judge one claim and compute Task A scores."""
+    load_dotenv()
+    google = (
+        os.getenv("GOOGLE_GENAI_API_KEY")
+        or os.getenv("GEMINI_API_KEY")
+        or os.getenv("GOOGLE_API_KEY")
+        or ""
+    ).strip()
+    if google:
+        os.environ.setdefault("GEMINI_API_KEY", google)
+        os.environ.setdefault("GOOGLE_API_KEY", google)
+
+    matching = asyncio.run(
+        judge_ingredient_matching(
+            judge_model, claim, gold_ingredients, predicted_ingredients
+        )
+    )
+    matches = matching.get("matches") or []
+    full_pairs = maximum_full_matching(
+        matches, len(gold_ingredients), len(predicted_ingredients)
+    )
+    n_matched = len(full_pairs)
+    n_ref = len(gold_ingredients)
+    n_pred = len(predicted_ingredients)
+    recall = (n_matched / n_ref) if n_ref else 0.0
+    precision = (n_matched / n_pred) if n_pred else 0.0
+    f1 = (
+        (2 * precision * recall / (precision + recall))
+        if (precision + recall)
+        else 0.0
+    )
+
+    # Build recall_judgments for UI gold column.
+    full_by_ref = {m["reference_idx"]: m for m in full_pairs}
+    partial_by_ref: dict[int, list[dict]] = {}
+    for m in matches:
+        if m.get("match") == "partial":
+            partial_by_ref.setdefault(m["reference_idx"], []).append(m)
+
+    judgments = []
+    for i, g in enumerate(gold_ingredients, start=1):
+        desc = str(g.get("enabling_contribution") or g.get("description") or "")
+        ann = g.get("canonical_annotation") or {}
+        role = ""
+        if isinstance(ann.get("roles"), list) and ann["roles"]:
+            role = str(ann["roles"][0])
+        else:
+            role = str(ann.get("role") or "")
+        full = full_by_ref.get(i)
+        partials = partial_by_ref.get(i) or []
+        if full:
+            pred = predicted_ingredients[full["predicted_idx"] - 1]
+            judgments.append(
+                {
+                    "reference_idx": i,
+                    "reference_ingredient": desc,
+                    "reference_role": role,
+                    "covered": True,
+                    "best_match_idx": full["predicted_idx"],
+                    "reasoning": full.get("reasoning", ""),
+                    "best_match": pred,
+                    "partial_matches": [],
+                }
+            )
+        else:
+            judgments.append(
+                {
+                    "reference_idx": i,
+                    "reference_ingredient": desc,
+                    "reference_role": role,
+                    "covered": False,
+                    "best_match_idx": None,
+                    "reasoning": "",
+                    "best_match": None,
+                    "partial_matches": [
+                        {
+                            "reference_idx": p["reference_idx"],
+                            "predicted_idx": p["predicted_idx"],
+                            "match": "partial",
+                            "reasoning": p.get("reasoning", ""),
+                        }
+                        for p in partials
+                    ],
+                }
+            )
+
+    return {
+        "recall": recall,
+        "precision": precision,
+        "f1": f1,
+        "matched_pairs": full_pairs,
+        "partial_matches": [m for m in matches if m.get("match") == "partial"],
+        "recall_judgments": judgments,
+        "gold_ingredients": _gold_to_ui_ingredients(gold_ingredients),
+        "predicted_ingredients": predicted_ingredients,
+        "judge_model": judge_model,
+    }

hf_space/scipath_live/pipeline.py

@@ -0,0 +1,101 @@
+"""High-level Live Run API used by Streamlit (self-contained)."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from pathlib import Path
+from typing import Any, Optional
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+DATA_DIR = PACKAGE_DIR / "data"
+EXAMPLE_CLAIM_PATH = DATA_DIR / "example_claim.json"
+DEFAULT_RUNS_ROOT = PACKAGE_DIR.parent / "runs" / "system_live"
+
+METHOD_CLI = {
+    "codeagent_parametric": "parametric",
+    "parametric": "parametric",
+    "codeagent_websearch_deep": "websearch_deep",
+    "websearch_deep": "websearch_deep",
+}
+
+
+def load_example_claim(path: Optional[Path] = None) -> dict[str, Any]:
+    claim_path = Path(path) if path else EXAMPLE_CLAIM_PATH
+    data = json.loads(claim_path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict) or not data.get("claim"):
+        raise ValueError(f"Invalid example claim at {claim_path}")
+    return data
+
+
+def new_job_dir(runs_root: Optional[Path] = None, method: str = "parametric") -> Path:
+    root = Path(runs_root) if runs_root else DEFAULT_RUNS_ROOT
+    job = root / f"job_{method}_{uuid.uuid4().hex[:10]}"
+    job.mkdir(parents=True, exist_ok=True)
+    return job
+
+
+def run_method(
+    method_id: str,
+    *,
+    claim_record: Optional[dict[str, Any]] = None,
+    output_dir: Optional[Path] = None,
+    model_name: str = "gemini-3-flash-preview",
+) -> dict[str, Any]:
+    """Run parametric or websearch_deep on the demo example claim (or provided record)."""
+    method = METHOD_CLI.get(method_id)
+    if not method:
+        raise ValueError(f"Unknown method id: {method_id}")
+    from .agent import run_claim_to_dir
+
+    record = claim_record or load_example_claim()
+    out_dir = Path(output_dir) if output_dir else new_job_dir(method=method)
+    result = run_claim_to_dir(
+        claim=str(record["claim"]),
+        paper_id=str(record.get("paper_id") or "example"),
+        claim_idx=int(record.get("claim_idx") or 0),
+        paper_title=str(record.get("paper_title") or ""),
+        method=method,
+        output_dir=out_dir,
+        model_name=model_name,
+    )
+    result["output_dir"] = str(out_dir)
+    result["method_id"] = (
+        "codeagent_parametric" if method == "parametric" else "codeagent_websearch_deep"
+    )
+    return result
+
+
+def evaluate_task_a(
+    *,
+    run_result: dict[str, Any],
+    claim_record: Optional[dict[str, Any]] = None,
+    judge_model: str = "gemini/gemini-3.1-pro-preview",
+) -> dict[str, Any]:
+    """Judge a finished live run against gold enabling contributions."""
+    from .judge import evaluate_prediction
+
+    record = claim_record or load_example_claim()
+    gold = list(record.get("enabling_contributions") or [])
+    predicted = list(run_result.get("ingredients") or [])
+    judged = evaluate_prediction(
+        claim=str(record.get("claim") or run_result.get("claim") or ""),
+        gold_ingredients=gold,
+        predicted_ingredients=predicted,
+        judge_model=judge_model,
+    )
+    payload = {
+        "paper_id": record.get("paper_id"),
+        "claim_idx": record.get("claim_idx"),
+        "paper_title": record.get("paper_title"),
+        "claim": record.get("claim"),
+        "method_id": run_result.get("method_id"),
+        "method": run_result.get("method"),
+        **judged,
+    }
+    out_dir = run_result.get("output_dir")
+    if out_dir:
+        path = Path(out_dir) / "task_a_judged.json"
+        path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        payload["judged_path"] = str(path)
+    return payload

hf_space/scipath_live/prompts.py

@@ -0,0 +1,170 @@
+"""SciPath Task A prompts and answer validation (demo-local copy)."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+SCIPATH_ROLES = {
+    "CORE_METHOD",
+    "CONCEPTUAL_FRAMEWORK",
+    "DATA_SOURCE",
+    "TRAINING_DATA",
+    "MODEL_INITIALIZATION",
+    "EVALUATION_PROTOCOL",
+    "IMPLEMENTATION_TOOLING",
+}
+
+TOOLS_GUIDE_PARAMETRIC = ""
+
+TOOLS_GUIDE_WEBSEARCH_DEEP = """
+    You have access to web search and must use it to get relevant information about the claim.
+    <tools>
+        - web_search_tool(): get a list of (url,summary of the webpage) from the WWW
+        - deep_web_search_tool(): retrieve content from a website given the url. The content is a dictionary with keys 'title', 'url' and 'content'.
+    </tools>
+    """
+
+PROCEDURE_PARAMETRIC = """
+<procedure>
+Step 1. Analyze the discovery claim and identify necessary enabling contributions from your knowledge.
+Step 2. Validate JSON with check_answer_format(), then return final_answer().
+</procedure>
+"""
+
+PROCEDURE_WEBSEARCH_DEEP = """
+<procedure>
+Step 1. Decompose the claim into a set of searchable short queries.
+Step 2. Start from the first query. Use web_search_tool() to get relevant information about the claim.
+Step 2.1. Based on the snippets, select the most relevant urls from search results and use deep_web_search_tool() on each url to get more relevant context.
+Step 2.2. If the collected information is sufficient, proceed to Step 3. Otherwise, move to the next query and repeat Step 2.
+Step 3. Summarize all the information retrieved from the web.
+Step 4. Synthesize the minimal set of enabling contributions as JSON ingredients.
+Step 5. Validate JSON with check_answer_format(), then return final_answer() with the ingredients object.
+</procedure>
+"""
+
+SCIPATH_OUTPUT_SPEC = """
+<output>
+Return a JSON object with exactly one top-level key: "ingredients".
+
+Each ingredient must have:
+- "description": concise functional description of the enabling contribution
+- "role": one of CORE_METHOD, CONCEPTUAL_FRAMEWORK, DATA_SOURCE, TRAINING_DATA,
+  MODEL_INITIALIZATION, EVALUATION_PROTOCOL, IMPLEMENTATION_TOOLING
+- "rationale": one sentence explaining why it is necessary
+
+Example:
+{
+  "ingredients": [
+    {
+      "description": "Pretrained transformer encoder for sentence embeddings",
+      "role": "MODEL_INITIALIZATION",
+      "rationale": "Needed to initialize the downstream model used in the discovery."
+    }
+  ]
+}
+
+Rules:
+- Only include necessary enabling contributions for realizing the discovery claim.
+- Exclude generic background, motivation, baselines, and comparison-only datasets.
+- Use concrete strings; never copy placeholder values such as "...".
+- Invoke check_answer_format() on your JSON, then call final_answer() with the same object.
+</output>
+"""
+
+SCIPATH_TASK_DESCRIPTION = """
+You are forecasting enabling contributions required to realize a scientific discovery claim
+(SciPath Task A, Setting 1: claim only).
+
+An enabling contribution is a functional component whose absence would prevent the discovery
+from being realized in its claimed form. It may come from prior work or be paper-specific
+(e.g., a data pipeline or annotation procedure).
+
+Use available search/retrieval tools when present to identify plausible prior work, then
+synthesize the minimal set of enabling contributions.
+"""
+
+SCIPATH_MUST_FOLLOW = """
+<must follow conditions>
+- Gather evidence with tools before producing the final ingredient list when tools are available.
+- Separate evidence gathering from final synthesis across steps.
+- NEVER return final_answer without validating via check_answer_format().
+- Write only one code block per step when executing code.
+</must follow conditions>
+"""
+
+_METHOD_TOOLS = {
+    "parametric": TOOLS_GUIDE_PARAMETRIC,
+    "websearch_deep": TOOLS_GUIDE_WEBSEARCH_DEEP,
+}
+
+_METHOD_PROCEDURE = {
+    "parametric": PROCEDURE_PARAMETRIC,
+    "websearch_deep": PROCEDURE_WEBSEARCH_DEEP,
+}
+
+
+def get_scipath_controller_prompt(query: str, method: str) -> str:
+    tools = _METHOD_TOOLS.get(method, TOOLS_GUIDE_WEBSEARCH_DEEP)
+    procedure = _METHOD_PROCEDURE.get(method, PROCEDURE_WEBSEARCH_DEEP)
+    return f"""
+{SCIPATH_TASK_DESCRIPTION}
+
+{tools}
+
+{procedure}
+
+{SCIPATH_OUTPUT_SPEC}
+
+{SCIPATH_MUST_FOLLOW}
+
+Discovery claim:
+{query}
+"""
+
+
+def validate_scipath_answer(final_answer_dict: dict) -> tuple[bool, str | None, dict | None]:
+    if not isinstance(final_answer_dict, dict):
+        return False, "Final answer must be a JSON object.", None
+
+    ingredients = final_answer_dict.get("ingredients")
+    if not isinstance(ingredients, list) or not ingredients:
+        return False, "Field 'ingredients' must be a non-empty list.", None
+
+    placeholder_values = {"", "...", "…", "null", "none", "n/a"}
+    cleaned: list[dict[str, str]] = []
+    for idx, ingredient in enumerate(ingredients):
+        if not isinstance(ingredient, dict):
+            return False, f"Ingredient {idx} must be an object.", None
+        description = str(ingredient.get("description", "")).strip()
+        role = str(ingredient.get("role", "")).strip().upper()
+        rationale = str(ingredient.get("rationale", "")).strip()
+        if (
+            description.lower() in placeholder_values
+            or role.lower() in placeholder_values
+            or rationale.lower() in placeholder_values
+        ):
+            return False, f"Ingredient {idx} contains placeholder or empty fields.", None
+        if role not in SCIPATH_ROLES:
+            return False, f"Ingredient {idx} has invalid role {role!r}.", None
+        cleaned.append(
+            {"description": description, "role": role, "rationale": rationale}
+        )
+
+    return True, None, {"ingredients": cleaned}
+
+
+def parse_ingredients_from_answer(answer: Any) -> list[dict]:
+    if isinstance(answer, str):
+        try:
+            answer = json.loads(answer)
+        except json.JSONDecodeError:
+            return []
+    if not isinstance(answer, dict):
+        return []
+    if isinstance(answer.get("ingredients"), list):
+        ok, _, validated = validate_scipath_answer(answer)
+        if ok and validated:
+            return validated["ingredients"]
+    return []

hf_space/scipath_live/tools.py

@@ -0,0 +1,170 @@
+"""Tools for SciPath Live: format check, web search, deep page fetch."""
+
+from __future__ import annotations
+
+import os
+import re
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+import requests
+from pydantic import ValidationError
+from smolagents import DuckDuckGoSearchTool, tool
+
+from .prompts import validate_scipath_answer
+
+WEBSEARCH_TOOL = DuckDuckGoSearchTool(max_results=5, rate_limit=2)
+
+# Prefer demo-local browser cache over Cursor/temp PLAYWRIGHT_BROWSERS_PATH.
+_DEMO_PLAYWRIGHT_DIR = Path(__file__).resolve().parents[2] / ".playwright"
+
+
+def _ensure_playwright_browsers_path() -> Path:
+    _DEMO_PLAYWRIGHT_DIR.mkdir(parents=True, exist_ok=True)
+    os.environ["PLAYWRIGHT_BROWSERS_PATH"] = str(_DEMO_PLAYWRIGHT_DIR)
+    return _DEMO_PLAYWRIGHT_DIR
+
+
+def _parse_search_results(search_output: str) -> list[dict[str, str]]:
+    evidence_items: list[dict[str, str]] = []
+    pattern = r"\[([^\]]+)\]\(([^\)]+)\)(.*?)(?=\[|$)"
+    for match in re.finditer(pattern, search_output or "", re.DOTALL):
+        title = match.group(1).strip()
+        url = match.group(2).strip()
+        content = match.group(3).strip()
+        summary = content.split("·", 1)[1].strip() if "·" in content else content
+        summary = " ".join(summary.split()).rstrip("…").strip()
+        if summary:
+            evidence_items.append(
+                {
+                    "type": "web_search_result",
+                    "source": url,
+                    "summary": f"{title}. {summary}",
+                }
+            )
+    return evidence_items
+
+
+def _get_pdf_content(url: str) -> dict[str, str]:
+    try:
+        import PyPDF2
+
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        pdf_reader = PyPDF2.PdfReader(BytesIO(response.content))
+        pages = []
+        for i, page in enumerate(pdf_reader.pages):
+            pages.append(page.extract_text() or "")
+            if i >= 29:
+                break
+        content = "\n\n".join(pages)
+        if "Abstract" in content:
+            content = content.split("Abstract", 1)[1]
+        title = "PDF Document"
+        if pdf_reader.metadata and getattr(pdf_reader.metadata, "title", None):
+            title = pdf_reader.metadata.title or title
+        return {"title": title, "url": url, "content": content}
+    except Exception as exc:
+        return {"title": "Error", "url": url, "content": f"Error extracting PDF: {exc}"}
+
+
+def get_webpage(url: str) -> dict[str, str]:
+    """Fetch webpage or PDF content (Playwright for HTML, PyPDF2 for PDFs)."""
+    if "sciencedirect" in url:
+        return {
+            "title": "ScienceDirect Article",
+            "url": url,
+            "content": "Automatically fetching content from ScienceDirect is not supported.",
+        }
+    if url.lower().endswith(".pdf"):
+        return _get_pdf_content(url)
+
+    try:
+        from playwright.sync_api import sync_playwright
+    except Exception as exc:
+        return {
+            "title": "Error",
+            "url": url,
+            "content": f"Playwright unavailable: {exc}",
+        }
+
+    browsers_dir = _ensure_playwright_browsers_path()
+
+    def _launch_browser(playwright_api: Any) -> Any:
+        # Prefer installed Google Chrome (matches host arch) when available.
+        try:
+            return playwright_api.chromium.launch(channel="chrome", headless=True)
+        except Exception:
+            return playwright_api.chromium.launch(headless=True)
+
+    try:
+        with sync_playwright() as p:
+            browser = _launch_browser(p)
+            try:
+                page = browser.new_page()
+                page.goto(url, timeout=15000)
+                page.wait_for_load_state("domcontentloaded")
+                title = page.title() or ""
+                text = (
+                    page.inner_text("body")
+                    if page.locator("body").count()
+                    else page.content()
+                )
+                # Cap content size for the agent context.
+                text = (text or "")[:40000]
+                return {"title": title, "url": page.url, "content": text}
+            except Exception:
+                return _get_pdf_content(url)
+            finally:
+                browser.close()
+    except Exception as exc:
+        msg = str(exc)
+        if "Executable doesn't exist" in msg or "browserType.launch" in msg.lower():
+            return {
+                "title": "Error",
+                "url": url,
+                "content": (
+                    "Playwright Chromium is not installed for this demo. "
+                    f"Run: bash scripts/setup_playwright.sh "
+                    f"(PLAYWRIGHT_BROWSERS_PATH={browsers_dir})"
+                ),
+            }
+        return {"title": "Error", "url": url, "content": f"Playwright error: {exc}"}
+
+
+@tool
+def check_answer_format(final_answer_dict: dict) -> Any:
+    """Validate the final SciPath ingredients JSON format.
+
+    Args:
+        final_answer_dict: the final answer/output that is to be returned to the user
+    """
+    try:
+        ok, err, validated = validate_scipath_answer(final_answer_dict)
+        return ok, err, validated
+    except ValidationError as e:
+        return False, str(e), None
+    except Exception as e:
+        return False, f"Unexpected error: {e}", None
+
+
+@tool
+def web_search_tool(short_search_query: str) -> list[dict]:
+    """Perform a web search and return structured results.
+
+    Args:
+        short_search_query: A concise search query (typically 1-6 words)
+    """
+    search_results = WEBSEARCH_TOOL(short_search_query)
+    return _parse_search_results(search_results)
+
+
+@tool
+def deep_web_search_tool(url: str) -> dict:
+    """Fetch and return webpage/PDF content for a URL.
+
+    Args:
+        url: the url of a webpage
+    """
+    return get_webpage(url)

hf_space/streamlit_config.py

@@ -0,0 +1,50 @@
+from workflow_graph import STEP_COPY
+
+EXAMPLES = {
+    "Paper 1": "https://arxiv.org/abs/2208.00329",
+    # AveriTeC demo hidden from the picker for now.
+    # "Paper 2 (AveriTeC)": "https://arxiv.org/abs/2505.17978",
+    "Paper 2": "https://arxiv.org/abs/2211.08788",
+}
+
+# System Run setting picker labels (match SciPaths Dev case-study report).
+SYSTEM_RUN_METHODS = {
+    "Parametric - LLM Only": "codeagent_parametric",
+    "Websearch Deep - LLM + Web Search + Crawl": "codeagent_websearch_deep",
+}
+
+TAB_NAMES = [
+    "Run",
+    "Clusters",
+    "Decomposition",
+]
+
+APP_VIEWS = [
+    "Annotation Process",
+    "System Run",
+]
+
+# Left-nav items (mina-style icon + label rows). Icons use Streamlit Material symbols.
+APP_NAV = [
+    {
+        "view": "Annotation Process",
+        "icon": ":material/account_tree:",
+    },
+    {
+        "view": "System Run",
+        "icon": ":material/play_circle:",
+    },
+]
+
+METHOD_NOTES = {
+    "Pipeline scope": "Runs steps 0, 1, 2, 3, 4, 5, 6, and 8, then launches cluster-first two-pass annotation.",
+    "Input": "Accepts a single arXiv URL or arXiv ID.",
+    "Cluster-first annotation": "Uses all refined downstream USES/EXTENDS clusters to derive target contributions, then decomposes each target contribution separately.",
+    "Stopping rule": "If no valid downstream usage clusters remain after refinement and filtering, annotation is skipped.",
+}
+
+DISPLAY_STEPS = [1, 2, 3, 4, 5, 6, 7, 8]
+
+
+def pipeline_steps_markdown() -> str:
+    return "\n".join(f"{idx}. {STEP_COPY[idx]}" for idx in DISPLAY_STEPS)

hf_space/system_live_runner.py

@@ -0,0 +1,317 @@
+"""Streamlit helpers for System Run → Live Run (self-contained scipath_live)."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+from scipath_live.pipeline import (
+    DEFAULT_RUNS_ROOT,
+    load_example_claim,
+    new_job_dir,
+)
+
+HF_SPACE = Path(__file__).resolve().parent
+DEMO_ROOT = HF_SPACE.parent
+CLI = HF_SPACE / "scipath_live" / "cli.py"
+# Stable browser cache for this demo (avoids Cursor sandbox temp paths).
+PLAYWRIGHT_BROWSERS_DIR = DEMO_ROOT / ".playwright"
+
+METHOD_UI = [
+    {"id": "codeagent_parametric", "cli": "parametric", "label": "Parametric - LLM Only"},
+    {
+        "id": "codeagent_websearch_deep",
+        "cli": "websearch_deep",
+        "label": "Websearch Deep - LLM + Web Search + Crawl",
+    },
+]
+
+
+def example_claim() -> dict[str, Any]:
+    return load_example_claim()
+
+
+def _env_for_child() -> dict[str, str]:
+    env = dict(os.environ)
+    # Prefer demo-local .env if present.
+    for candidate in (HF_SPACE / ".env", HF_SPACE.parent / ".env"):
+        if not candidate.exists():
+            continue
+        try:
+            from dotenv import dotenv_values
+
+            for key, value in dotenv_values(candidate).items():
+                if value and key not in env:
+                    env[key] = value
+        except Exception:
+            pass
+    google = (
+        env.get("GOOGLE_GENAI_API_KEY")
+        or env.get("GEMINI_API_KEY")
+        or env.get("GOOGLE_API_KEY")
+        or ""
+    ).strip()
+    if google:
+        env["GEMINI_API_KEY"] = google
+        env["GOOGLE_API_KEY"] = google
+        env["GOOGLE_GENAI_API_KEY"] = google
+    env["PYTHONPATH"] = (
+        f"{HF_SPACE}{os.pathsep}{env.get('PYTHONPATH', '')}".rstrip(os.pathsep)
+    )
+    # Stream agent prints line-by-line into the Live Run terminal.
+    env["PYTHONUNBUFFERED"] = "1"
+    env["PYTHONIOENCODING"] = "utf-8"
+    # Always use demo-local Playwright browsers (override Cursor sandbox cache).
+    PLAYWRIGHT_BROWSERS_DIR.mkdir(parents=True, exist_ok=True)
+    env["PLAYWRIGHT_BROWSERS_PATH"] = str(PLAYWRIGHT_BROWSERS_DIR)
+    return env
+
+
+def _is_result_payload_line(line: str) -> bool:
+    text = (line or "").strip()
+    return text.startswith("{") and '"ok"' in text
+
+
+def _append_trace_from_logs_jsonl(
+    job_dir: Path, log_callback: Optional[Callable[[str], None]]
+) -> None:
+    """Fallback: if stdout missed the trace, reconstruct from logs.jsonl."""
+    if not log_callback:
+        return
+    path = job_dir / "logs.jsonl"
+    if not path.exists():
+        return
+    try:
+        from scipath_live.agent import format_agent_trace
+
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        steps = payload.get("steps") or []
+        for line in format_agent_trace(steps):
+            log_callback(line)
+    except Exception as exc:
+        log_callback(f"[warn] Could not load agent trace: {exc}")
+
+
+def run_live_method(
+    method_id: str,
+    *,
+    log_callback: Optional[Callable[[str], None]] = None,
+    model_name: str = "gemini-3-flash-preview",
+) -> dict[str, Any]:
+    """Subprocess-run a method; stream stdout lines via log_callback."""
+    cli_method = next((m["cli"] for m in METHOD_UI if m["id"] == method_id), None)
+    if not cli_method:
+        raise ValueError(f"Unknown method: {method_id}")
+
+    job_dir = new_job_dir(DEFAULT_RUNS_ROOT, method=cli_method)
+    cmd = [
+        sys.executable,
+        str(CLI),
+        "run",
+        "--method",
+        cli_method,
+        "--output-dir",
+        str(job_dir),
+        "--model",
+        model_name,
+    ]
+    if log_callback:
+        log_callback(f"$ {' '.join(cmd)}")
+
+    proc = subprocess.Popen(
+        cmd,
+        cwd=str(HF_SPACE),
+        env=_env_for_child(),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+    )
+    assert proc.stdout is not None
+    last_json = ""
+    saw_trace = False
+    for line in proc.stdout:
+        line = line.rstrip("\n")
+        if not line:
+            continue
+        if _is_result_payload_line(line):
+            # Keep machine payload out of the human terminal.
+            last_json = line
+            continue
+        if "SciFy CodeAgent trace" in line:
+            saw_trace = True
+        if log_callback:
+            log_callback(line)
+    code = proc.wait()
+    if code != 0:
+        raise RuntimeError(f"Live run failed with exit code {code}")
+
+    if last_json:
+        payload = json.loads(last_json)
+        if not payload.get("ok"):
+            raise RuntimeError(payload.get("error") or "Live run failed")
+        result = payload["result"]
+    else:
+        # Fallback: read result.json written by the agent.
+        result_path = job_dir / "result.json"
+        if not result_path.exists():
+            raise RuntimeError("Live run produced no result.json")
+        result = json.loads(result_path.read_text(encoding="utf-8"))
+        result["output_dir"] = str(job_dir)
+        result["method_id"] = method_id
+
+    if not saw_trace:
+        _append_trace_from_logs_jsonl(job_dir, log_callback)
+
+    result.setdefault("output_dir", str(job_dir))
+    result.setdefault("method_id", method_id)
+    return result
+
+
+def evaluate_live_run(
+    run_result: dict[str, Any],
+    *,
+    log_callback: Optional[Callable[[str], None]] = None,
+    judge_model: str = "gemini/gemini-3.1-pro-preview",
+) -> dict[str, Any]:
+    result_json = Path(run_result.get("output_dir") or ".") / "result.json"
+    if not result_json.exists():
+        # Write a minimal result file for the CLI.
+        result_json.parent.mkdir(parents=True, exist_ok=True)
+        result_json.write_text(
+            json.dumps(run_result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+        )
+
+    cmd = [
+        sys.executable,
+        str(CLI),
+        "evaluate",
+        "--result-json",
+        str(result_json),
+        "--judge-model",
+        judge_model,
+    ]
+    if log_callback:
+        log_callback(f"$ {' '.join(cmd)}")
+
+    proc = subprocess.run(
+        cmd,
+        cwd=str(HF_SPACE),
+        env=_env_for_child(),
+        capture_output=True,
+        text=True,
+    )
+    if log_callback and proc.stdout:
+        for line in proc.stdout.splitlines():
+            log_callback(line)
+    if proc.returncode != 0:
+        err = (proc.stderr or proc.stdout or "").strip()
+        raise RuntimeError(err or f"Evaluate failed with exit code {proc.returncode}")
+
+    # Last JSON line is the payload.
+    payload = None
+    for line in reversed((proc.stdout or "").splitlines()):
+        if line.startswith("{"):
+            payload = json.loads(line)
+            break
+    if not payload or not payload.get("ok"):
+        raise RuntimeError((payload or {}).get("error") or "Evaluate produced no result")
+    return payload["judged"]
+
+
+def live_result_to_case_card(run_result: dict[str, Any], judged: Optional[dict] = None) -> dict[str, Any]:
+    """Normalize live artifacts into the System Run case-card shape."""
+    method_id = run_result.get("method_id") or "codeagent_parametric"
+    method_label = next(
+        (m["label"] for m in METHOD_UI if m["id"] == method_id), method_id
+    )
+    predicted = []
+    source_pred = (judged or {}).get("predicted_ingredients") or run_result.get("ingredients") or []
+    for i, item in enumerate(source_pred, start=1):
+        if not isinstance(item, dict):
+            continue
+        predicted.append(
+            {
+                "idx": i,
+                "description": str(item.get("description") or ""),
+                "role": str(item.get("role") or ""),
+                "rationale": str(item.get("rationale") or ""),
+            }
+        )
+
+    if judged:
+        gold = []
+        for j in judged.get("recall_judgments") or []:
+            gold.append(
+                {
+                    "description": str(j.get("reference_ingredient") or ""),
+                    "role": str(j.get("reference_role") or ""),
+                    "badge": (
+                        "full"
+                        if j.get("covered")
+                        else ("partial" if j.get("partial_matches") else "miss")
+                    ),
+                    "match_notes": [],
+                    "judge_note": str(j.get("reasoning") or ""),
+                    "pair_pred_idx": j.get("best_match_idx"),
+                }
+            )
+            # Reconstruct match notes for partials
+            for pm in j.get("partial_matches") or []:
+                gold[-1]["match_notes"].append(
+                    f"Partial ↔ pred #{pm.get('predicted_idx')}: {pm.get('reasoning', '')}"
+                )
+                if gold[-1]["badge"] == "miss":
+                    gold[-1]["badge"] = "partial"
+        # Live Run is not framed as success/failure — always yellow (part).
+        f1 = float(judged.get("f1") or 0.0)
+        return {
+            "method_id": method_id,
+            "method_label": method_label.split(" - ")[0],
+            "case_key": "live",
+            "case_chip": f"{method_label.split(' - ')[0]} · Live",
+            "outcome_tone": "part",
+            "tools": (
+                ["check_answer_format"]
+                if "parametric" in method_id
+                else ["web_search_tool", "deep_web_search_tool", "check_answer_format"]
+            ),
+            "paper_id": judged.get("paper_id") or run_result.get("paper_id"),
+            "claim_idx": judged.get("claim_idx") or run_result.get("claim_idx"),
+            "paper_title": judged.get("paper_title") or run_result.get("paper_title"),
+            "claim": judged.get("claim") or run_result.get("claim"),
+            "recall": float(judged.get("recall") or 0.0),
+            "precision": float(judged.get("precision") or 0.0),
+            "f1": f1,
+            "gold_ingredients": gold,
+            "predicted_ingredients": predicted,
+            "tool_panel": {"kind": "none"},
+        }
+
+    # Pre-evaluate: predictions only.
+    return {
+        "method_id": method_id,
+        "method_label": method_label.split(" - ")[0],
+        "case_key": "featured",
+        "case_chip": f"{method_label.split(' - ')[0]} · Live (unevaluated)",
+        "outcome_tone": "part",
+        "tools": (
+            ["check_answer_format"]
+            if "parametric" in method_id
+            else ["web_search_tool", "deep_web_search_tool", "check_answer_format"]
+        ),
+        "paper_id": run_result.get("paper_id"),
+        "claim_idx": run_result.get("claim_idx"),
+        "paper_title": run_result.get("paper_title"),
+        "claim": run_result.get("claim"),
+        "recall": 0.0,
+        "precision": 0.0,
+        "f1": 0.0,
+        "gold_ingredients": [],
+        "predicted_ingredients": predicted,
+        "tool_panel": {"kind": "none"},
+    }

hf_space/system_run_cases/case_study_analysis.json

@@ -0,0 +1,829 @@
+{
+  "title": "SciPaths Dev Case Studies across CodeAgent settings",
+  "analysis_model": "gemini/gemini-3.1-pro-preview",
+  "settings": {
+    "codeagent_parametric": {
+      "tools": [
+        "check_answer_format"
+      ],
+      "summary_meta": {
+        "source": "gold",
+        "gold_file": "/Users/dingzifeng/SciFy-UMBC/dryrun/ForecastingDiscoveryPathways-7FCC/archive/dev.json",
+        "gold_claim_field": "rewritten_capability",
+        "setting": 1,
+        "generator_model": "gemini-3-flash-preview",
+        "generator_backend": "codeagent",
+        "codeagent_method": "parametric",
+        "n_claims": 50,
+        "n_total_claims": 50,
+        "n_errors": 0,
+        "mean_n_predicted": 4.56
+      },
+      "success": {
+        "paper_id": "neurips-2023-poster-2075",
+        "claim_idx": 0,
+        "paper_title": "Pick-a-Pic: An Open Dataset of User Preferences for Text-to-Image Generation",
+        "claim": "Tool: A human-preference prompt-conditioned image scorer, enabling automatic ranking of text-to-image model outputs",
+        "recall": 1.0,
+        "precision": 0.75,
+        "f1": 0.857,
+        "predicted_ingredients": [
+          {
+            "description": "Large-scale dataset of human pairwise preferences for generated images",
+            "role": "TRAINING_DATA",
+            "rationale": "Necessary to provide the ground-truth human judgments required to train the scorer for alignment with subjective preferences."
+          },
+          {
+            "description": "Pre-trained vision-language model backbone (e.g., CLIP)",
+            "role": "MODEL_INITIALIZATION",
+            "rationale": "Provides the foundational cross-modal representations needed to assess the semantic relationship between text prompts and visual content."
+          },
+          {
+            "description": "Prompt-conditioned reward modeling architecture and objective",
+            "role": "CORE_METHOD",
+            "rationale": "Defines the specific neural network structure and loss function used to map image-text pairs to a scalar preference score."
+          },
+          {
+            "description": "Human-preference alignment evaluation benchmark",
+            "role": "EVALUATION_PROTOCOL",
+            "rationale": "Required to validate that the automated scorer's rankings accurately reflect human preferences on unseen samples."
+          }
+        ],
+        "recall_judgments": [
+          {
+            "reference_idx": 1,
+            "reference_ingredient": "Pre-trained vision-language encoder for prompt-conditioned image scoring",
+            "reference_role": "MODEL_INITIALIZATION",
+            "covered": true,
+            "best_match_idx": 2,
+            "reasoning": "Both describe the use of a pre-trained vision-language model (like CLIP) to initialize the cross-modal representations.",
+            "best_match": {
+              "description": "Pre-trained vision-language model backbone (e.g., CLIP)",
+              "role": "MODEL_INITIALIZATION",
+              "rationale": "Provides the foundational cross-modal representations needed to assess the semantic relationship between text prompts and visual content."
+            },
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 2,
+            "reference_ingredient": "Large-scale human-preference dataset over text-to-image generations",
+            "reference_role": "TRAINING_DATA",
+            "covered": true,
+            "best_match_idx": 1,
+            "reasoning": "Both explicitly identify the large-scale dataset of pairwise human preferences over generated images as the training data.",
+            "best_match": {
+              "description": "Large-scale dataset of human pairwise preferences for generated images",
+              "role": "TRAINING_DATA",
+              "rationale": "Necessary to provide the ground-truth human judgments required to train the scorer for alignment with subjective preferences."
+            },
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 3,
+            "reference_ingredient": "Pairwise preference-learning objective for reward-style image ranking",
+            "reference_role": "CORE_METHOD",
+            "covered": true,
+            "best_match_idx": 3,
+            "reasoning": "Both specify the reward-modeling/preference-learning objective required to train the scoring function to reflect human preferences.",
+            "best_match": {
+              "description": "Prompt-conditioned reward modeling architecture and objective",
+              "role": "CORE_METHOD",
+              "rationale": "Defines the specific neural network structure and loss function used to map image-text pairs to a scalar preference score."
+            },
+            "partial_matches": []
+          }
+        ],
+        "matched_pairs": [
+          {
+            "reference_idx": 1,
+            "predicted_idx": 2,
+            "match": "full",
+            "reasoning": "Both describe the use of a pre-trained vision-language model (like CLIP) to initialize the cross-modal representations."
+          },
+          {
+            "reference_idx": 2,
+            "predicted_idx": 1,
+            "match": "full",
+            "reasoning": "Both explicitly identify the large-scale dataset of pairwise human preferences over generated images as the training data."
+          },
+          {
+            "reference_idx": 3,
+            "predicted_idx": 3,
+            "match": "full",
+            "reasoning": "Both specify the reward-modeling/preference-learning objective required to train the scoring function to reflect human preferences."
+          }
+        ],
+        "partial_matches": [],
+        "log_line": 19,
+        "n_steps": 2,
+        "tool_summary": {
+          "searches": [],
+          "retrieves": [],
+          "deeps": []
+        }
+      },
+      "failure": {
+        "paper_id": "neurips-2024-poster-219",
+        "claim_idx": 0,
+        "paper_title": "RGFN: Synthesizable Molecular Generation Using GFlowNets",
+        "claim": "Method: A generative framework for synthesizable molecular design, enabling generation of molecular candidates together with feasible synthesis pathways.",
+        "recall": 0.0,
+        "precision": 0.0,
+        "f1": 0.0,
+        "predicted_ingredients": [
+          {
+            "description": "Markov Decision Process (MDP) formulation of molecular synthesis",
+            "role": "CONCEPTUAL_FRAMEWORK",
+            "rationale": "Frames the generation of molecules as a sequence of discrete synthetic steps, ensuring the output is synthesizable by construction."
+          },
+          {
+            "description": "Library of reaction templates extracted from reaction databases (e.g., USPTO)",
+            "role": "DATA_SOURCE",
+            "rationale": "Provides the set of valid chemical transformations that the generative model can use to build molecules."
+          },
+          {
+            "description": "Database of commercially available building blocks",
+            "role": "DATA_SOURCE",
+            "rationale": "Serves as the required starting materials for any proposed synthesis pathway."
+          },
+          {
+            "description": "Neural policy network for reaction and building block selection",
+            "role": "CORE_METHOD",
+            "rationale": "The primary engine that learns to navigate the chemical space by selecting optimal synthetic actions."
+          },
+          {
+            "description": "Synthetic feasibility and property evaluation protocol",
+            "role": "EVALUATION_PROTOCOL",
+            "rationale": "Used to validate that the generated molecules meet the desired chemical properties and that the pathways are realistic."
+          }
+        ],
+        "recall_judgments": [
+          {
+            "reference_idx": 1,
+            "reference_ingredient": "Generative Flow Network (GFlowNet) framework trained with trajectory balance",
+            "reference_role": "CORE_METHOD",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 1,
+                "predicted_idx": 1,
+                "match": "partial",
+                "reasoning": "The predicted item captures the sequential MDP formulation underlying the generation process but is too broad and misses the specific GFlowNet framework and trajectory balance."
+              }
+            ]
+          },
+          {
+            "reference_idx": 2,
+            "reference_ingredient": "Graph transformer architecture for state and action representation",
+            "reference_role": "CORE_METHOD",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 2,
+                "predicted_idx": 4,
+                "match": "partial",
+                "reasoning": "The predicted item identifies the neural policy network used to navigate the space but lacks the specific graph transformer architecture required by the reference."
+              }
+            ]
+          },
+          {
+            "reference_idx": 3,
+            "reference_ingredient": "Predefined action space of robust chemical reaction templates and molecular building blocks",
+            "reference_role": "CONCEPTUAL_FRAMEWORK",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 3,
+                "predicted_idx": 2,
+                "match": "partial",
+                "reasoning": "The predicted item captures the reaction templates portion of the reference's predefined action space but omits the molecular building blocks."
+              },
+              {
+                "reference_idx": 3,
+                "predicted_idx": 3,
+                "match": "partial",
+                "reasoning": "The predicted item captures the molecular building blocks portion of the reference's action space but omits the reaction templates."
+              }
+            ]
+          },
+          {
+            "reference_idx": 4,
+            "reference_ingredient": "Fingerprint-based action embedding scheme for scalable fragment selection",
+            "reference_role": "CORE_METHOD",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 5,
+            "reference_ingredient": "Training loss of the model",
+            "reference_role": "CORE_METHOD",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": []
+          }
+        ],
+        "matched_pairs": [],
+        "partial_matches": [
+          {
+            "reference_idx": 1,
+            "predicted_idx": 1,
+            "match": "partial",
+            "reasoning": "The predicted item captures the sequential MDP formulation underlying the generation process but is too broad and misses the specific GFlowNet framework and trajectory balance."
+          },
+          {
+            "reference_idx": 2,
+            "predicted_idx": 4,
+            "match": "partial",
+            "reasoning": "The predicted item identifies the neural policy network used to navigate the space but lacks the specific graph transformer architecture required by the reference."
+          },
+          {
+            "reference_idx": 3,
+            "predicted_idx": 2,
+            "match": "partial",
+            "reasoning": "The predicted item captures the reaction templates portion of the reference's predefined action space but omits the molecular building blocks."
+          },
+          {
+            "reference_idx": 3,
+            "predicted_idx": 3,
+            "match": "partial",
+            "reasoning": "The predicted item captures the molecular building blocks portion of the reference's action space but omits the reaction templates."
+          }
+        ],
+        "log_line": 38,
+        "n_steps": 2,
+        "tool_summary": {
+          "searches": [],
+          "retrieves": [],
+          "deeps": []
+        }
+      },
+      "gemini_analysis": {
+        "tooling_clarification": "No external search or retrieval tools were provided for evidence gathering. The agent relied entirely on its internal parametric memory, using tools only to verify the output format.",
+        "success_why": [
+          "The model successfully recalled the exact architecture and training data for 'Pick-a-Pic', a prominent 2023 text-to-image alignment dataset.",
+          "It accurately identified the CLIP backbone, the large-scale human preference dataset, and the reward modeling objective without needing external grounding."
+        ],
+        "success_tool_role": [
+          "No evidence tools were used.",
+          "Success was driven entirely by the LLM's strong parametric knowledge of highly cited, recent (2023) multimodal AI research."
+        ],
+        "failure_diagnosis": "Faced with a highly specific 2024 molecular design paper (RGFN), the model hallucinated a generic, plausible pipeline for synthesizable molecular generation (MDP, USPTO templates, neural policy network) but completely missed the actual GFlowNet methodology.",
+        "failure_error_bullets": [
+          "[Missed core method] Failed to identify the GFlowNet framework and graph transformer architectures.",
+          "[Wrong specificity] Predicted a generic Markov Decision Process (MDP) instead of the specific GFlowNet trained with trajectory balance.",
+          "[Missing data/source] Missed the fingerprint-based action embedding scheme."
+        ],
+        "failure_what_needed": [
+          "External retrieval of the paper's abstract to ground the generic claim ('generative framework for synthesizable molecular design') to the specific RGFN/GFlowNet methodology."
+        ]
+      }
+    },
+    "codeagent_retrieval_plus_websearch": {
+      "tools": [
+        "retrieve_documents",
+        "web_search_tool",
+        "check_answer_format"
+      ],
+      "summary_meta": {
+        "source": "gold",
+        "gold_file": "/Users/dingzifeng/SciFy-UMBC/dryrun/ForecastingDiscoveryPathways-7FCC/archive/dev.json",
+        "gold_claim_field": "rewritten_capability",
+        "setting": 1,
+        "generator_model": "gemini-3-flash-preview",
+        "generator_backend": "codeagent",
+        "codeagent_method": "retrieval_plus_websearch",
+        "n_claims": 50,
+        "n_total_claims": 50,
+        "n_errors": 0,
+        "mean_n_predicted": 4.7
+      },
+      "case": {
+        "paper_id": "2023.acl-short.123",
+        "claim_idx": 0,
+        "paper_title": "An Embarrassingly Easy but Strong Baseline for Nested Named Entity Recognition",
+        "claim": "Tool: A standardized preprocessing and split-construction workflow for nested NER benchmarks, enabling fair comparison across models.",
+        "recall": 0.5,
+        "precision": 0.2,
+        "f1": 0.286,
+        "predicted_ingredients": [
+          {
+            "description": "Original nested NER datasets (e.g., GENIA, ACE 2004, ACE 2005)",
+            "role": "DATA_SOURCE",
+            "rationale": "These provide the raw annotated text data that the workflow standardizes for benchmarking purposes."
+          },
+          {
+            "description": "Unified data representation format for nested entities",
+            "role": "CONCEPTUAL_FRAMEWORK",
+            "rationale": "A consistent schema is necessary to represent overlapping spans across diverse datasets in a single format."
+          },
+          {
+            "description": "Automated preprocessing pipeline for tokenization and span alignment",
+            "role": "CORE_METHOD",
+            "rationale": "Ensures that all datasets are processed using identical linguistic rules to prevent bias from different tokenizers."
+          },
+          {
+            "description": "Standardized split-construction protocol (e.g., Lu and Roth splits)",
+            "role": "EVALUATION_PROTOCOL",
+            "rationale": "Guarantees that models are compared on identical subsets of the data to maintain experimental fairness."
+          },
+          {
+            "description": "Nested span evaluation metric implementation",
+            "role": "EVALUATION_PROTOCOL",
+            "rationale": "Required to accurately and consistently measure performance on overlapping entity structures across different models."
+          }
+        ],
+        "recall_judgments": [
+          {
+            "reference_idx": 1,
+            "reference_ingredient": "Raw nested NER corpora",
+            "reference_role": "DATA_SOURCE",
+            "covered": true,
+            "best_match_idx": 1,
+            "reasoning": "Both identify the original nested NER corpora (such as ACE2004, ACE2005, and GENIA) that provide the raw annotated text data for standardization.",
+            "best_match": {
+              "description": "Original nested NER datasets (e.g., GENIA, ACE 2004, ACE 2005)",
+              "role": "DATA_SOURCE",
+              "rationale": "These provide the raw annotated text data that the workflow standardizes for benchmarking purposes."
+            },
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 2,
+            "reference_ingredient": "Tokenization and annotation correction heuristics",
+            "reference_role": "IMPLEMENTATION_TOOLING",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 2,
+                "predicted_idx": 3,
+                "match": "partial",
+                "reasoning": "Both refer to the tokenization and span alignment process, but the reference specifies the underlying heuristics to fix tokenization and annotation conflicts, whereas the prediction describes the broader automated pipeline."
+              }
+            ]
+          }
+        ],
+        "retrieved_doc_titles": [
+          "Statistical Learning for Accurate and Interpretable Battery Lifetime Prediction",
+          "Accurate Performance Characterization, Reporting, and Benchmarking for Indoor Photovoltaics",
+          "Efficient implicit integration for finite-strain viscoplasticity with a nested multiplicative split",
+          "Prediction of charge separation in GaAs/AlAs cylindrical nanostructures",
+          "Effect of the structure of lead iodine perovskites on the photovoltaic efficiencies",
+          "The high strain-rate behaviour of three molecular weights of polyethylene examined with a magnesium alloy split-Hopkinson pressure bar",
+          "Landau Theory of Charge and Spin Ordering in the Nickelates",
+          "Excitonic effects in two-dimensional semiconductors: Path integral Monte Carlo approach"
+        ],
+        "gemini_analysis": {
+          "model": "gemini/gemini-3.1-pro-preview",
+          "focus": "performance when retrieval returned docs",
+          "headline": "Even with web search plus returned retrieval docs, the pathway stayed weakly grounded: retrieval was off-domain, so the model leaned on parametric knowledge and over-generated (F1 0.29).",
+          "what_was_retrieved": [
+            "Web search was used in most steps (alongside retrieval early, then alone later), with queries about nested NER preprocessing / benchmark standardization.",
+            "Retrieval returned documents from unrelated domains (materials science, physics, battery lifetime), likely via polysemous terms such as \"nested\", \"split\", and \"benchmarking\".",
+            "No retrieved documents were about NLP / Named Entity Recognition."
+          ],
+          "effect_on_prediction": [
+            "With off-domain retrieval and no strong grounding from tools, the model fell back on parametric knowledge of nested NER workflows.",
+            "That fallback recovered some recall (e.g., raw nested NER corpora / GENIA & ACE-style datasets) and a partial match on tokenization preprocessing.",
+            "Without relevant tool text to constrain the pathway, it also over-generated extra workflow pieces (unified format, evaluation metric), hurting precision (P=0.2)."
+          ],
+          "error_taxonomy_bullets": [
+            "[Domain Mismatch in Retrieval] Returned abstracts matched generic keywords to the wrong scientific fields, so retrieval did not surface the gold ingredients.",
+            "[Web search under-used for grounding] Despite repeated nested-NER web queries, the final ingredients still look like a generic preprocessing pipeline rather than the paper-specific tokenization/annotation heuristics.",
+            "[Parametric Reliance + Over-generation] The model filled gaps from memory and added plausible but non-gold steps, lowering precision."
+          ],
+          "takeaway": "Web search ran throughout the trajectory, including after documents were returned. Retrieval returned materials/physics papers rather than nested-NER sources, so neither tool provided the specific gold ingredients.",
+          "web_search_also_used": true,
+          "web_search_queries_example": [
+            "standardized preprocessing nested NER benchmarks workflow",
+            "nested NER benchmarks fair comparison tool",
+            "nested NER dataset preprocessing standardization",
+            "standardizing nested NER benchmarks"
+          ]
+        }
+      }
+    },
+    "codeagent_websearch_deep": {
+      "tools": [
+        "web_search_tool",
+        "deep_web_search_tool",
+        "check_answer_format"
+      ],
+      "summary_meta": {
+        "generator_model": "gemini-3-flash-preview",
+        "generator_backend": "codeagent",
+        "codeagent_method": "websearch_deep",
+        "mean_f1": 0.318,
+        "n_claims": 50
+      },
+      "success": {
+        "paper_id": "neurips-2025-spotlight-472",
+        "claim_idx": 1,
+        "paper_title": "ShapeLLM-Omni: A Native Multimodal LLM for 3D Generation and Understanding",
+        "claim": "Resource: A native 3D multimodal language model, enabling unified text, image, and 3D generation, understanding, and language-guided editing.",
+        "recall": 1.0,
+        "precision": 1.0,
+        "f1": 1.0,
+        "predicted_ingredients": [
+          {
+            "description": "3D Vector-Quantized Variational Autoencoder (VQVAE)",
+            "role": "CORE_METHOD",
+            "rationale": "Necessary to map 3D objects into a discrete latent space of 3D-aware tokens that the LLM can natively process and generate."
+          },
+          {
+            "description": "3D-Alpaca Dataset",
+            "role": "TRAINING_DATA",
+            "rationale": "A large-scale instruction-tuning dataset required to train the model on unified 3D generation, understanding, and editing tasks."
+          },
+          {
+            "description": "Qwen-2.5-vl-7B-Instruct",
+            "role": "MODEL_INITIALIZATION",
+            "rationale": "Provides the foundational multimodal (text and image) capabilities that are extended to include 3D functionality."
+          },
+          {
+            "description": "Unified Token-based Multimodal Architecture",
+            "role": "CONCEPTUAL_FRAMEWORK",
+            "rationale": "Enables the model to treat 3D tokens as a native modality alongside text and images for interleaved generation and understanding."
+          }
+        ],
+        "recall_judgments": [
+          {
+            "reference_idx": 1,
+            "reference_ingredient": "Pretrained multimodal vision-language backbone",
+            "reference_role": "MODEL_INITIALIZATION",
+            "covered": true,
+            "best_match_idx": 3,
+            "reasoning": "Both identify the pretrained Qwen-2.5-VL vision-language model used as the foundational backbone for initialization.",
+            "best_match": {
+              "description": "Qwen-2.5-vl-7B-Instruct",
+              "role": "MODEL_INITIALIZATION",
+              "rationale": "Provides the foundational multimodal (text and image) capabilities that are extended to include 3D functionality."
+            },
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 2,
+            "reference_ingredient": "Discrete 3D tokenization through a 3D VQVAE",
+            "reference_role": "CORE_METHOD",
+            "covered": true,
+            "best_match_idx": 1,
+            "reasoning": "Both describe the use of a 3D VQVAE to convert 3D objects into discrete tokens that the model can process natively.",
+            "best_match": {
+              "description": "3D Vector-Quantized Variational Autoencoder (VQVAE)",
+              "role": "CORE_METHOD",
+              "rationale": "Necessary to map 3D objects into a discrete latent space of 3D-aware tokens that the LLM can natively process and generate."
+            },
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 3,
+            "reference_ingredient": "Fully autoregressive early-fusion next-token modeling over text, image-conditioned inputs, and 3D tokens",
+            "reference_role": "CONCEPTUAL_FRAMEWORK, CORE_METHOD",
+            "covered": true,
+            "best_match_idx": 4,
+            "reasoning": "Both refer to the unified, token-based conceptual framework that treats 3D, text, and image tokens in a single interleaved architecture.",
+            "best_match": {
+              "description": "Unified Token-based Multimodal Architecture",
+              "role": "CONCEPTUAL_FRAMEWORK",
+              "rationale": "Enables the model to treat 3D tokens as a native modality alongside text and images for interleaved generation and understanding."
+            },
+            "partial_matches": []
+          },
+          {
+            "reference_idx": 4,
+            "reference_ingredient": "3D instruction-tuning corpus",
+            "reference_role": "TRAINING_DATA",
+            "covered": true,
+            "best_match_idx": 2,
+            "reasoning": "Both specify the 3D-Alpaca instruction-tuning dataset used to train and adapt the model for 3D tasks.",
+            "best_match": {
+              "description": "3D-Alpaca Dataset",
+              "role": "TRAINING_DATA",
+              "rationale": "A large-scale instruction-tuning dataset required to train the model on unified 3D generation, understanding, and editing tasks."
+            },
+            "partial_matches": []
+          }
+        ],
+        "matched_pairs": [
+          {
+            "reference_idx": 1,
+            "predicted_idx": 3,
+            "match": "full",
+            "reasoning": "Both identify the pretrained Qwen-2.5-VL vision-language model used as the foundational backbone for initialization."
+          },
+          {
+            "reference_idx": 2,
+            "predicted_idx": 1,
+            "match": "full",
+            "reasoning": "Both describe the use of a 3D VQVAE to convert 3D objects into discrete tokens that the model can process natively."
+          },
+          {
+            "reference_idx": 3,
+            "predicted_idx": 4,
+            "match": "full",
+            "reasoning": "Both refer to the unified, token-based conceptual framework that treats 3D, text, and image tokens in a single interleaved architecture."
+          },
+          {
+            "reference_idx": 4,
+            "predicted_idx": 2,
+            "match": "full",
+            "reasoning": "Both specify the 3D-Alpaca instruction-tuning dataset used to train and adapt the model for 3D tasks."
+          }
+        ]
+      },
+      "failure": {
+        "paper_id": "neurips-2023-poster-1534",
+        "claim_idx": 0,
+        "paper_title": "Continuous-Time Functional Diffusion Processes",
+        "claim": "Method: A diffusion-based generative framework for continuous function spaces, enabling modeling of continuous and irregularly sampled data.",
+        "recall": 0.0,
+        "precision": 0.0,
+        "f1": 0.0,
+        "predicted_ingredients": [
+          {
+            "description": "Denoising diffusion probabilistic modeling adapted for finite-dimensional marginals of functions",
+            "role": "CORE_METHOD",
+            "rationale": "Provides the generative mechanism to sample from functional distributions by reversing a noise process applied to function values at arbitrary locations."
+          },
+          {
+            "description": "Permutation-invariant attention-based architecture",
+            "role": "IMPLEMENTATION_TOOLING",
+            "rationale": "Ensures the model can process sets of input-output pairs of varying sizes while satisfying the exchangeability property required for stochastic processes."
+          },
+          {
+            "description": "Conceptual framework of exchangeability and consistency for stochastic processes",
+            "role": "CONCEPTUAL_FRAMEWORK",
+            "rationale": "Provides the theoretical foundation for defining a valid distribution over an infinite-dimensional function space via its finite marginals."
+          },
+          {
+            "description": "Coordinate-based representation of data observations",
+            "role": "CONCEPTUAL_FRAMEWORK",
+            "rationale": "Enables the model to handle irregularly sampled data by treating observations as evaluations of a function at specific continuous coordinates."
+          },
+          {
+            "description": "Score-based or denoising objective defined over function values at given coordinates",
+            "role": "CORE_METHOD",
+            "rationale": "Allows the model to learn the underlying structure of the function space by predicting noise or scores at arbitrary input points."
+          }
+        ],
+        "recall_judgments": [
+          {
+            "reference_idx": 1,
+            "reference_ingredient": "Score-based generative modeling with continuous-time stochastic differential equations",
+            "reference_role": "CONCEPTUAL_FRAMEWORK",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 1,
+                "predicted_idx": 1,
+                "match": "partial",
+                "reasoning": "Both identify the core diffusion generative mechanism, but the reference specifies a continuous-time SDE formulation while the prediction focuses on adapting diffusion for finite marginals."
+              },
+              {
+                "reference_idx": 1,
+                "predicted_idx": 5,
+                "match": "partial",
+                "reasoning": "Both highlight the score-based or denoising formulation, though the prediction restricts it to function values at given coordinates."
+              }
+            ]
+          },
+          {
+            "reference_idx": 2,
+            "reference_ingredient": "Infinite-dimensional stochastic differential equation framework for forward and reverse diffusion in Hilbert spaces",
+            "reference_role": "CONCEPTUAL_FRAMEWORK",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 2,
+                "predicted_idx": 3,
+                "match": "partial",
+                "reasoning": "Both provide the theoretical foundation for defining distributions over infinite-dimensional function spaces, but use different mathematical frameworks (Hilbert space SDEs versus exchangeability/consistency)."
+              }
+            ]
+          },
+          {
+            "reference_idx": 3,
+            "reference_ingredient": "Countable-evaluation formulation that connects continuous functions to discrete observations for practical learning and inference",
+            "reference_role": "CORE_METHOD",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 3,
+                "predicted_idx": 1,
+                "match": "partial",
+                "reasoning": "Both address the need to connect continuous function spaces to discrete observations (countable evaluations versus finite-dimensional marginals) for practical inference."
+              },
+              {
+                "reference_idx": 3,
+                "predicted_idx": 4,
+                "match": "partial",
+                "reasoning": "Both focus on bridging continuous functions with discrete data points, though they describe it differently (countable-evaluation formulation versus coordinate-based representations)."
+              }
+            ]
+          },
+          {
+            "reference_idx": 4,
+            "reference_ingredient": "Implicit neural representation-based practical implementation of the functional score network",
+            "reference_role": "CORE_METHOD",
+            "covered": false,
+            "best_match_idx": null,
+            "reasoning": "",
+            "best_match": null,
+            "partial_matches": [
+              {
+                "reference_idx": 4,
+                "predicted_idx": 4,
+                "match": "partial",
+                "reasoning": "Implicit neural representations are a form of coordinate-based representation, but the prediction describes applying them to data observations rather than the functional score network."
+              }
+            ]
+          }
+        ],
+        "partial_matches": [
+          {
+            "reference_idx": 1,
+            "predicted_idx": 1,
+            "match": "partial",
+            "reasoning": "Both identify the core diffusion generative mechanism, but the reference specifies a continuous-time SDE formulation while the prediction focuses on adapting diffusion for finite marginals."
+          },
+          {
+            "reference_idx": 1,
+            "predicted_idx": 5,
+            "match": "partial",
+            "reasoning": "Both highlight the score-based or denoising formulation, though the prediction restricts it to function values at given coordinates."
+          },
+          {
+            "reference_idx": 2,
+            "predicted_idx": 3,
+            "match": "partial",
+            "reasoning": "Both provide the theoretical foundation for defining distributions over infinite-dimensional function spaces, but use different mathematical frameworks (Hilbert space SDEs versus exchangeability/consistency)."
+          },
+          {
+            "reference_idx": 3,
+            "predicted_idx": 1,
+            "match": "partial",
+            "reasoning": "Both address the need to connect continuous function spaces to discrete observations (countable evaluations versus finite-dimensional marginals) for practical inference."
+          },
+          {
+            "reference_idx": 3,
+            "predicted_idx": 4,
+            "match": "partial",
+            "reasoning": "Both focus on bridging continuous functions with discrete data points, though they describe it differently (countable-evaluation formulation versus coordinate-based representations)."
+          },
+          {
+            "reference_idx": 4,
+            "predicted_idx": 4,
+            "match": "partial",
+            "reasoning": "Implicit neural representations are a form of coordinate-based representation, but the prediction describes applying them to data observations rather than the functional score network."
+          }
+        ]
+      },
+      "gemini_analysis": {
+        "model": "gemini/gemini-3.1-pro-preview",
+        "focus": "tool-aware (web_search_tool + deep_web_search_tool)",
+        "tooling_clarification": "The agent uses `web_search_tool` to retrieve search engine snippets and `deep_web_search_tool` to fetch and read full webpage content. There is no 'crawl' tool; `deep_web_search_tool` is the sole mechanism for extracting full-text page content.",
+        "success_search_contribution": [
+          "Formulated targeted queries (e.g., 'native 3D multimodal language model unified text image 3D generation') to locate primary and secondary sources for ShapeLLM-Omni.",
+          "Successfully identified the project page ('jamesyjl.github.io/ShapeLLM/') as a viable alternative source.",
+          "Used follow-up searches ('ShapeLLM-Omni 3D-Alpaca dataset source Objaverse') to verify specific entities like '3D-Alpaca' and '3D-aware discrete tokens' found in earlier steps."
+        ],
+        "success_deep_contribution": [
+          "Attempted to fetch the arXiv HTML ('https://arxiv.org/html/2506.01853v1') but encountered a PDF parse error ('No /Root object!'), prompting a necessary pivot.",
+          "Successfully fetched the project page ('https://jamesyjl.github.io/ShapeLLM/'), extracting exact architectural details ('3D VQVAE', 'Qwen-2.5-vl-7B-Instruct') and dataset names ('3D-Alpaca') that perfectly aligned with the gold ingredients."
+        ],
+        "success_why_overall": [
+          "The agent demonstrated tool resilience by pivoting to a project page when the primary arXiv HTML deep-fetch failed.",
+          "The deep-fetched project page contained highly specific, structured information about the method's architecture and training data, which the agent accurately synthesized into the final ingredients."
+        ],
+        "failure_diagnosis": "The agent successfully surfaced the correct paper via search but failed to deep-fetch any of its URLs, instead deep-fetching and extracting ingredients from a neighboring method (Neural Diffusion Processes).",
+        "failure_search_what_went_wrong": [
+          "Search successfully found the correct target paper ('Continuous-Time Functional Diffusion Processes') and its URLs (NeurIPS abstract, arXiv HTML, GitHub project page) in steps 5 and 7.",
+          "Search snippets contained highly relevant gold terms (e.g., 'hilbert-spaces', 'stochastic-partial-differential-equations'), but the agent ignored them.",
+          "The agent incorrectly pivoted its search strategy to query a neighboring method ('Neural Diffusion Processes Dutordoir ICML 2023 architecture')."
+        ],
+        "failure_deep_what_went_wrong": [
+          "Never called `deep_web_search_tool` on the correct FDP URLs found in search (e.g., 'arxiv.org/html/2303.00800v3').",
+          "Wasted deep-fetch calls on guessed/wrong arXiv IDs (e.g., 2303.01631, 2205.15306) which returned completely unrelated papers.",
+          "Deep-fetched OpenReview and PMLR pages for the wrong paper ('Neural Diffusion Processes'), leading to the extraction of incorrect methodological details."
+        ],
+        "failure_error_bullets": [
+          "[Substitutes neighboring method] The agent extracted ingredients for 'Neural Diffusion Processes' (finite marginals, exchangeability, attention) instead of the gold 'Functional Diffusion Processes' (Hilbert-space SDEs, countable evaluation, INR) because it deep-fetched the wrong paper's PMLR page.",
+          "[Candidate retrieval failure] Although `web_search_tool` surfaced the correct URLs, the agent failed to retrieve their full content via `deep_web_search_tool`, relying instead on deep-fetches of incorrect papers.",
+          "[Missed core method] By focusing on the wrong paper's deep-fetched content, the agent completely missed the core continuous-time SDE and Hilbert space framework of the target paper."
+        ],
+        "failure_what_needed": [
+          "The agent needed to pass the correct URLs found by `web_search_tool` (e.g., 'https://arxiv.org/html/2303.00800v3') directly into `deep_web_search_tool` instead of guessing arXiv IDs or pivoting to fetch pages for Neural Diffusion Processes."
+        ]
+      },
+      "tool_traces": {
+        "tools_available": {
+          "web_search_tool": "Broad web search; returns list of {source URL, summary}. NOT a crawler.",
+          "deep_web_search_tool": "Given a URL, fetches webpage/PDF content as {title,url,content}. This is the page-fetch / crawl-like tool. There is NO separate tool named crawl.",
+          "check_answer_format": "Validates final JSON schema."
+        },
+        "success": {
+          "paper_id": "neurips-2025-spotlight-472",
+          "claim_idx": 1,
+          "n_steps": 4,
+          "web_search_queries": [
+            "native 3D multimodal language model unified text image 3D generation",
+            "3D multimodal language model understanding and language-guided editing",
+            "native 3D-LLM text image 3D generation understanding editing",
+            "ShapeLLM-Omni 3D-Alpaca dataset source Objaverse"
+          ],
+          "web_search_hits_notable": [
+            "arxiv.org/html/2506.01853v1 ShapeLLM-Omni",
+            "neurips.cc/virtual/2025/poster/116179 mentioning 3D-Alpaca",
+            "project page jamesyjl.github.io/ShapeLLM/"
+          ],
+          "deep_fetches": [
+            {
+              "url": "https://arxiv.org/html/2506.01853v1",
+              "outcome": "FAILED: Error fetching webpage: No /Root object! - Is this really a PDF?"
+            },
+            {
+              "url": "https://jamesyjl.github.io/ShapeLLM/",
+              "outcome": "SUCCESS: project page content mentioning ShapeLLM-Omni, 3D tokens, training dataset details, backbone mentions"
+            }
+          ],
+          "final_ingredients": [
+            "3D VQVAE",
+            "3D-Alpaca Dataset",
+            "Qwen-2.5-vl-7B-Instruct",
+            "Unified Token-based Multimodal Architecture"
+          ]
+        },
+        "failure": {
+          "paper_id": "neurips-2023-poster-1534",
+          "claim_idx": 0,
+          "n_steps": 17,
+          "web_search_queries_sample": [
+            "diffusion-based generative framework for continuous function spaces",
+            "score-based generative modeling in function space",
+            "Functional Diffusion Processes NeurIPS 2023",
+            "Continuous-Time Functional Diffusion Processes irregularly sampled data",
+            "Neural Diffusion Processes Dutordoir ICML 2023 architecture"
+          ],
+          "web_search_correct_hits_but_underused": [
+            "NeurIPS 2023 abstract page for Continuous-Time Functional Diffusion Processes (found in step 5)",
+            "arxiv.org/html/2303.00800v3 Continuous-Time Functional Diffusion Processes (found in step 7)",
+            "1zb.github.io/functional-diffusion/ project page (found in step 7)"
+          ],
+          "deep_fetches": [
+            {
+              "url": "https://arxiv.org/abs/2302.03046",
+              "intended": "guessed target paper",
+              "outcome": "attempted in malformed multi-code step; no usable obs"
+            },
+            {
+              "url": "https://arxiv.org/abs/2303.01631",
+              "intended": "FDP paper",
+              "outcome": "WRONG PAPER: Real-Time Tube-Based Non-Gaussian Risk Bounded Motion Planning..."
+            },
+            {
+              "url": "https://arxiv.org/abs/2205.15306",
+              "intended": "Neural Diffusion Processes",
+              "outcome": "WRONG PAPER: How to Compose Shortest Paths"
+            },
+            {
+              "url": "https://openreview.net/forum?id=tV7GSY5GYG",
+              "intended": "NDP OpenReview",
+              "outcome": "fetched NDP OpenReview page (neighboring method, not gold FDP)"
+            },
+            {
+              "url": "https://proceedings.mlr.press/v202/dutordoir23a.html",
+              "intended": "NDP PMLR",
+              "outcome": "fetched NDP paper page; agent synthesized NDP ingredients"
+            }
+          ],
+          "failure_mode_tooling": "Search surfaced the correct FDP paper, but deep_web_search_tool was applied to wrong arXiv IDs and then to a neighboring Neural Diffusion Processes paper. Final ingredients mirror NDP (finite marginals, exchangeability, attention) rather than FDP (Hilbert-space continuous-time SDEs, countable evaluation, INR score network)."
+        }
+      }
+    }
+  }
+}

hf_space/system_run_data.py

@@ -0,0 +1,444 @@
+"""Load curated System Run case studies for the Streamlit demo.
+
+Labels and section structure follow the SciPaths Dev · CodeAgent Case Studies HTML report.
+"""
+
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Optional
+
+CASES_DIR = Path(__file__).resolve().parent / "system_run_cases"
+ANALYSIS_PATH = CASES_DIR / "case_study_analysis.json"
+
+SYSTEM_RUN_METHODS: list[dict[str, str]] = [
+    {
+        "id": "codeagent_parametric",
+        "label": "Parametric - LLM Only",
+        "banner_title": "1 · codeagent_parametric",
+        "banner_desc": "Parametric-only generation (no search/retrieval). Mean F1 ≈ 0.20.",
+    },
+    {
+        "id": "codeagent_websearch_deep",
+        # Audience label: "Crawl" = deep_web_search_tool (page/PDF fetch; no separate crawl tool).
+        "label": "Websearch Deep - LLM + Web Search + Crawl",
+        "banner_title": "2 · codeagent_websearch_deep",
+        "banner_desc": (
+            "Tools: web_search_tool + deep_web_search_tool (page fetch / crawl). "
+            "Mean F1 ≈ 0.32."
+        ),
+    },
+]
+
+DEFAULT_SYSTEM_METHOD = SYSTEM_RUN_METHODS[0]["id"]
+DEFAULT_SYSTEM_CASE = "success"
+
+# Case keys exposed in the UI — labels match the HTML report.
+_METHOD_CASES: dict[str, list[tuple[str, str]]] = {
+    "codeagent_parametric": [("success", "Success"), ("failure", "Failure")],
+    "codeagent_websearch_deep": [("success", "Success"), ("failure", "Failure")],
+}
+
+CASE_OUTCOME_LABEL: dict[str, str] = {
+    "success": "Success",
+    "failure": "Failure",
+}
+
+TOOLING_NOTE_HTML = (
+    "<strong>Tooling by setting.</strong>"
+    "<br/>· <code>parametric</code>: parametric knowledge only (no search/retrieval)."
+    "<br/>· <code>websearch_deep</code>: <code>web_search_tool</code> + "
+    "<code>deep_web_search_tool</code> (URL page fetch)."
+)
+
+
+@lru_cache(maxsize=1)
+def load_analysis() -> dict[str, Any]:
+    with ANALYSIS_PATH.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    if not isinstance(data, dict):
+        raise ValueError(f"Invalid case study analysis at {ANALYSIS_PATH}")
+    return data
+
+
+def method_ids() -> list[str]:
+    return [m["id"] for m in SYSTEM_RUN_METHODS]
+
+
+def method_meta(method_id: str) -> dict[str, str]:
+    for m in SYSTEM_RUN_METHODS:
+        if m["id"] == method_id:
+            return m
+    return {"id": method_id, "label": method_id, "banner_title": method_id, "banner_desc": ""}
+
+
+def method_label(method_id: str) -> str:
+    return method_meta(method_id).get("label") or method_id
+
+
+def case_chip_label(method_id: str, case_key: str) -> str:
+    """Top-of-card label, e.g. 'Parametric · Success'."""
+    pretty = {
+        "codeagent_parametric": "Parametric",
+        "codeagent_websearch_deep": "WebSearch Deep",
+    }.get(method_id, method_label(method_id))
+    outcome = CASE_OUTCOME_LABEL.get(case_key, case_key)
+    return f"{pretty} · {outcome}"
+
+
+def list_cases(method_id: str) -> list[tuple[str, str]]:
+    return list(_METHOD_CASES.get(method_id, []))
+
+
+def default_case_for_method(method_id: str) -> str:
+    cases = list_cases(method_id)
+    return cases[0][0] if cases else DEFAULT_SYSTEM_CASE
+
+
+def outcome_tone(case_key: str, f1: float) -> str:
+    if case_key == "success":
+        return "ok"
+    if case_key == "failure":
+        return "bad"
+    if f1 >= 0.75:
+        return "ok"
+    if f1 <= 0.05:
+        return "bad"
+    return "part"
+
+
+def _setting(method_id: str) -> dict[str, Any]:
+    settings = load_analysis().get("settings") or {}
+    block = settings.get(method_id)
+    if not isinstance(block, dict):
+        raise KeyError(f"Unknown system-run method: {method_id}")
+    return block
+
+
+def _raw_case_block(method_id: str, case_key: str) -> dict[str, Any]:
+    setting = _setting(method_id)
+    if case_key == "featured":
+        block = setting.get("case")
+    else:
+        block = setting.get(case_key)
+    if not isinstance(block, dict):
+        raise KeyError(f"Unknown case {case_key!r} for method {method_id}")
+    return block
+
+
+def _gold_ingredients(case: dict[str, Any]) -> list[dict[str, Any]]:
+    """Gold column with full/partial/miss badges and match notes (HTML report style)."""
+    predicted = case.get("predicted_ingredients") or []
+    gold: list[dict[str, Any]] = []
+    for judgment in case.get("recall_judgments") or []:
+        if not isinstance(judgment, dict):
+            continue
+        desc = str(judgment.get("reference_ingredient") or "").strip()
+        role = str(judgment.get("reference_role") or "").strip()
+        if not desc:
+            continue
+        covered = bool(judgment.get("covered"))
+        partials = judgment.get("partial_matches") or []
+        if not isinstance(partials, list):
+            partials = []
+        match_notes: list[str] = []
+        judge_note = ""
+        pair_pred_idx: Optional[int] = None
+        if covered:
+            badge = "full"
+            best = judgment.get("best_match") if isinstance(judgment.get("best_match"), dict) else {}
+            best_desc = str(best.get("description") or "").strip()
+            if best_desc:
+                match_notes.append(f"Matched to pred: {best_desc}")
+            judge_note = str(judgment.get("reasoning") or "").strip()
+            raw_idx = judgment.get("best_match_idx")
+            if isinstance(raw_idx, int) and raw_idx > 0:
+                pair_pred_idx = raw_idx
+            elif best_desc:
+                # Fall back to description match against predicted list (1-based).
+                for i, pred in enumerate(predicted, start=1):
+                    if isinstance(pred, dict) and str(pred.get("description") or "").strip() == best_desc:
+                        pair_pred_idx = i
+                        break
+        elif partials:
+            badge = "partial"
+            for pm in partials:
+                if not isinstance(pm, dict):
+                    continue
+                pred_idx = pm.get("predicted_idx")
+                reason = str(pm.get("reasoning") or "").strip()
+                if pred_idx is not None and reason:
+                    match_notes.append(f"Partial ↔ pred #{pred_idx}: {reason}")
+                elif reason:
+                    match_notes.append(reason)
+        else:
+            badge = "miss"
+        gold.append(
+            {
+                "description": desc,
+                "role": role,
+                "badge": badge,
+                "match_notes": match_notes,
+                "judge_note": judge_note,
+                "pair_pred_idx": pair_pred_idx,
+            }
+        )
+    return gold
+
+
+def build_pair_rows(
+    gold: list[dict[str, Any]], predicted: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """Align gold↔prediction rows for success-case connector lines."""
+    by_idx = {
+        int(p["idx"]): p
+        for p in predicted
+        if isinstance(p.get("idx"), int)
+    }
+    used: set[int] = set()
+    rows: list[dict[str, Any]] = []
+    for g in gold:
+        pred_idx = g.get("pair_pred_idx")
+        pred = by_idx.get(int(pred_idx)) if isinstance(pred_idx, int) else None
+        linked = bool(pred is not None and g.get("badge") == "full")
+        if linked and isinstance(pred_idx, int):
+            used.add(pred_idx)
+        rows.append({"gold": g, "pred": pred, "linked": linked})
+    for p in predicted:
+        idx = p.get("idx")
+        if isinstance(idx, int) and idx not in used:
+            rows.append({"gold": None, "pred": p, "linked": False})
+    return rows
+
+
+def _tool_panel(method_id: str, case_key: str, case: dict[str, Any], setting: dict[str, Any]) -> dict[str, Any]:
+    """Structured tool evidence / traces for the case card."""
+    if method_id == "codeagent_retrieval_plus_websearch":
+        analysis = case.get("gemini_analysis") if isinstance(case.get("gemini_analysis"), dict) else {}
+        return {
+            "kind": "retrieval",
+            "intro": (
+                "This run used both retrieve_documents and web_search_tool. "
+                "Web search continued in later steps after documents were returned."
+            ),
+            "queries": list(analysis.get("web_search_queries_example") or []),
+            "retrieved_docs": list(case.get("retrieved_doc_titles") or []),
+        }
+
+    if method_id == "codeagent_websearch_deep":
+        traces = setting.get("tool_traces") if isinstance(setting.get("tool_traces"), dict) else {}
+        trace = traces.get("success" if case_key == "success" else "failure")
+        if not isinstance(trace, dict):
+            return {"kind": "none"}
+        deep_fetches = []
+        for item in trace.get("deep_fetches") or []:
+            if not isinstance(item, dict):
+                continue
+            outcome = str(item.get("outcome") or "")
+            ok = outcome.upper().startswith("SUCCESS")
+            deep_fetches.append(
+                {
+                    "url": str(item.get("url") or ""),
+                    "outcome": outcome,
+                    "ok": ok,
+                }
+            )
+        return {
+            "kind": "deep",
+            "queries": list(
+                trace.get("web_search_queries")
+                or trace.get("web_search_queries_sample")
+                or []
+            ),
+            "hits": list(
+                trace.get("web_search_hits_notable")
+                or trace.get("web_search_correct_hits_but_underused")
+                or []
+            ),
+            "deep_fetches": deep_fetches,
+        }
+
+    return {"kind": "none"}
+
+
+def get_case(method_id: str, case_key: str) -> dict[str, Any]:
+    """Normalized case card payload for the UI."""
+    setting = _setting(method_id)
+    case = _raw_case_block(method_id, case_key)
+    tools = [str(t) for t in (setting.get("tools") or [])]
+    predicted = []
+    for idx, item in enumerate(case.get("predicted_ingredients") or [], start=1):
+        if not isinstance(item, dict):
+            continue
+        predicted.append(
+            {
+                "idx": idx,
+                "description": str(item.get("description") or "").strip(),
+                "role": str(item.get("role") or "").strip(),
+                "rationale": str(item.get("rationale") or "").strip(),
+            }
+        )
+    f1 = float(case.get("f1") or 0.0)
+    return {
+        "method_id": method_id,
+        "method_label": method_label(method_id),
+        "case_key": case_key,
+        "case_chip": case_chip_label(method_id, case_key),
+        "outcome_tone": outcome_tone(case_key, f1),
+        "tools": tools,
+        "paper_id": str(case.get("paper_id") or ""),
+        "claim_idx": case.get("claim_idx"),
+        "paper_title": str(case.get("paper_title") or ""),
+        "claim": str(case.get("claim") or ""),
+        "recall": float(case.get("recall") or 0.0),
+        "precision": float(case.get("precision") or 0.0),
+        "f1": f1,
+        "gold_ingredients": _gold_ingredients(case),
+        "predicted_ingredients": predicted,
+        "tool_panel": _tool_panel(method_id, case_key, case, setting),
+        "banner": method_meta(method_id),
+    }
+
+
+def get_analysis(method_id: str, case_key: Optional[str] = None) -> dict[str, Any]:
+    setting = _setting(method_id)
+    if method_id == "codeagent_retrieval_plus_websearch":
+        case = setting.get("case") or {}
+        analysis = case.get("gemini_analysis") if isinstance(case, dict) else None
+        return dict(analysis) if isinstance(analysis, dict) else {}
+
+    analysis = setting.get("gemini_analysis")
+    if not isinstance(analysis, dict):
+        return {}
+    out = dict(analysis)
+    out["_case_key"] = case_key or ""
+    return out
+
+
+def analysis_view_for_case(method_id: str, case_key: str) -> dict[str, Any]:
+    """Structured analysis view matching HTML report headings."""
+    analysis = get_analysis(method_id, case_key)
+    if not analysis:
+        return {"model_tag": "Gemini 3.1 Pro analysis", "blocks": []}
+
+    blocks: list[dict[str, Any]] = []
+
+    if method_id == "codeagent_retrieval_plus_websearch":
+        headline = str(analysis.get("headline") or "").strip()
+        takeaway = str(analysis.get("takeaway") or "").strip()
+        diag = headline
+        if takeaway:
+            diag = f"{headline}\n{takeaway}" if headline else takeaway
+        if diag:
+            blocks.append({"type": "diagnosis", "text": diag, "strong_first": True})
+        two_col = []
+        for key, title in (
+            ("what_was_retrieved", "What the tools returned"),
+            ("effect_on_prediction", "Effect on prediction"),
+        ):
+            items = analysis.get(key)
+            if isinstance(items, list) and items:
+                two_col.append({"title": title, "items": [str(x) for x in items]})
+        if two_col:
+            blocks.append({"type": "two_col", "cols": two_col})
+        errs = analysis.get("error_taxonomy_bullets")
+        if isinstance(errs, list) and errs:
+            blocks.append(
+                {"type": "list", "title": "Error analysis", "items": [str(x) for x in errs]}
+            )
+        return {"model_tag": "Gemini 3.1 Pro analysis", "blocks": blocks}
+
+    if method_id == "codeagent_parametric":
+        if case_key == "success":
+            why = analysis.get("success_why")
+            if isinstance(why, list) and why:
+                blocks.append(
+                    {
+                        "type": "list",
+                        "title": "Why this succeeded",
+                        "items": [str(x) for x in why],
+                    }
+                )
+        else:
+            if analysis.get("failure_diagnosis"):
+                blocks.append(
+                    {
+                        "type": "diagnosis",
+                        "text": f"Diagnosis. {analysis['failure_diagnosis']}",
+                        "strong_first": True,
+                    }
+                )
+            errs = analysis.get("failure_error_bullets")
+            if isinstance(errs, list) and errs:
+                blocks.append(
+                    {
+                        "type": "list",
+                        "title": "Error taxonomy",
+                        "items": [str(x) for x in errs],
+                    }
+                )
+            needed = analysis.get("failure_what_needed")
+            if isinstance(needed, list) and needed:
+                blocks.append(
+                    {
+                        "type": "list",
+                        "title": "What recovery would have required",
+                        "items": [str(x) for x in needed],
+                    }
+                )
+        return {"model_tag": "Gemini 3.1 Pro analysis", "blocks": blocks}
+
+    # websearch_deep
+    if case_key == "success":
+        two_col = []
+        for key, title in (
+            ("success_search_contribution", "web_search_tool"),
+            ("success_deep_contribution", "deep_web_search_tool"),
+        ):
+            items = analysis.get(key)
+            if isinstance(items, list) and items:
+                two_col.append({"title": title, "items": [str(x) for x in items]})
+        if two_col:
+            blocks.append({"type": "two_col", "cols": two_col})
+        why = analysis.get("success_why_overall")
+        if isinstance(why, list) and why:
+            blocks.append(
+                {"type": "list", "title": "Why this succeeded", "items": [str(x) for x in why]}
+            )
+    else:
+        if analysis.get("failure_diagnosis"):
+            blocks.append(
+                {
+                    "type": "diagnosis",
+                    "text": f"Diagnosis. {analysis['failure_diagnosis']}",
+                    "strong_first": True,
+                }
+            )
+        two_col = []
+        for key, title in (
+            ("failure_search_what_went_wrong", "web_search_tool"),
+            ("failure_deep_what_went_wrong", "deep_web_search_tool"),
+        ):
+            items = analysis.get(key)
+            if isinstance(items, list) and items:
+                two_col.append({"title": title, "items": [str(x) for x in items]})
+        if two_col:
+            blocks.append({"type": "two_col", "cols": two_col})
+        errs = analysis.get("failure_error_bullets")
+        if isinstance(errs, list) and errs:
+            blocks.append(
+                {"type": "list", "title": "Error taxonomy", "items": [str(x) for x in errs]}
+            )
+        needed = analysis.get("failure_what_needed")
+        if isinstance(needed, list) and needed:
+            blocks.append(
+                {
+                    "type": "list",
+                    "title": "What recovery would have required",
+                    "items": [str(x) for x in needed],
+                }
+            )
+
+    return {"model_tag": "Gemini 3.1 Pro analysis", "blocks": blocks}

hf_space/workflow_graph.py

@@ -0,0 +1,1197 @@
+"""Evolving SciPaths workflow graph (Neo4j-backed).
+
+Visual formatting follows Mina Brain's knowledge-graph canvas strictly:
+filled circle + white inner stroke + colored ring, 25-char labels with white
+halo, expanding write-pulse rings, #fafbfd stage, click detail card.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+import streamlit as st
+
+try:
+    import neo4j_workflow as neo4j_store
+except Exception:  # pragma: no cover
+    neo4j_store = None  # type: ignore
+
+# Short labels shared by Steps panel + workflow graph captions.
+STEP_COPY: dict[int, str] = {
+    1: "Load the paper",
+    2: "Find where it’s cited",
+    3: "Collect citation contexts",
+    4: "Classify how it’s used",
+    5: "Keep real reuse (uses / extends)",
+    6: "Pull the citing passages",
+    7: "Group similar reuse themes and summarize target contributions",
+    8: "Find enabling contributions and corresponding prior studies",
+}
+
+WORK_PANEL_STEPS: list[tuple[int, str]] = [(n, STEP_COPY[n]) for n in range(1, 9)]
+
+CANVAS_LABEL_MAX = 25
+
+# Mina Brain NODE_COLORS mapped onto SciPaths kinds (fill / ring / text).
+KIND_META = {
+    "target": {
+        "fill": "#4F6EF7",
+        "ring": "#A5B4FC",
+        "text": "#1E3A8A",
+        "r": 22,
+        "type_label": "Target paper",
+        "color": "#4F6EF7",
+        "size": 22,
+    },
+    "citing": {
+        "fill": "#60A5FA",
+        "ring": "#BFDBFE",
+        "text": "#1D4ED8",
+        "r": 14,
+        "type_label": "Citing paper",
+        "color": "#60A5FA",
+        "size": 14,
+    },
+    "cluster": {
+        "fill": "#8B5CF6",
+        "ring": "#DDD6FE",
+        "text": "#5B21B6",
+        "r": 16,
+        "type_label": "Reuse theme",
+        "color": "#8B5CF6",
+        "size": 16,
+    },
+    "claim": {
+        "fill": "#FBBF24",
+        "ring": "#FDE68A",
+        "text": "#B45309",
+        "r": 15,
+        "type_label": "Target contribution",
+        "color": "#FBBF24",
+        "size": 15,
+    },
+    "ingredient": {
+        "fill": "#94A3B8",
+        "ring": "#E2E8F0",
+        "text": "#475569",
+        "r": 12,
+        "type_label": "Enabling contribution",
+        "color": "#94A3B8",
+        "size": 12,
+    },
+    "study": {
+        "fill": "#34D399",
+        "ring": "#A7F3D0",
+        "text": "#047857",
+        "r": 13,
+        "type_label": "Prior study",
+        "color": "#34D399",
+        "size": 13,
+    },
+}
+
+# Category order + compact per-kind palette the canvas shell + rail consume.
+_KIND_ORDER = ["target", "claim", "ingredient", "cluster", "study", "citing"]
+_KIND_META_JS = {
+    k: {"fill": v["fill"], "ring": v["ring"], "text": v["text"], "label": v["type_label"]}
+    for k, v in KIND_META.items()
+}
+
+
+def _load_json(path: Path) -> Any | None:
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _clean(text: str) -> str:
+    return re.sub(r"\s+", " ", (text or "").strip())
+
+
+def canvas_label(text: str, *, limit: int = CANVAS_LABEL_MAX) -> str:
+    cleaned = _clean(text)
+    if len(cleaned) <= limit:
+        return cleaned
+    return cleaned[:limit].rstrip() + "…"
+
+
+def visible_step_from_events(events: list[str]) -> int:
+    started = 0
+    for raw in events or []:
+        text = str(raw)
+        m = re.search(r"Step\s+(\d+)\s*(?:/|\s+complete)", text, re.IGNORECASE)
+        if m:
+            started = max(started, int(m.group(1)))
+            continue
+        lower = text.lower()
+        if "[annotation]" in lower or "annotate" in lower:
+            started = max(started, 8)
+    return min(8, started)
+
+
+def pulse_step_from_events(events: list[str]) -> int:
+    started: set[int] = set()
+    completed: set[int] = set()
+    for raw in events or []:
+        text = str(raw)
+        m_done = re.search(r"Step\s+(\d+)\s+complete", text, re.IGNORECASE)
+        if m_done:
+            completed.add(int(m_done.group(1)))
+            continue
+        m_start = re.search(r"Step\s+(\d+)\s*/", text)
+        if m_start:
+            started.add(int(m_start.group(1)))
+            continue
+        lower = text.lower()
+        if "[annotation]" in lower or "annotate" in lower:
+            if "complete" in lower or "skipped" in lower:
+                completed.add(8)
+            else:
+                started.add(8)
+    active = [n for n in sorted(started) if n not in completed]
+    return active[-1] if active else 0
+
+
+def _paper_title_from_dir(paper_dir: Optional[Path]) -> str:
+    if not paper_dir:
+        return "Target paper"
+    data = _load_json(paper_dir / "paper_metadata.json")
+    record = None
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        record = data[0]
+    elif isinstance(data, dict):
+        record = data
+    return _clean(str((record or {}).get("title") or "")) or "Target paper"
+
+
+def _paper_abstract_from_dir(paper_dir: Optional[Path]) -> str:
+    if not paper_dir:
+        return ""
+    data = _load_json(paper_dir / "paper_metadata.json")
+    record = None
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        record = data[0]
+    elif isinstance(data, dict):
+        record = data
+    abstract = _clean(str((record or {}).get("abstract") or ""))
+    abstract = re.sub(r"^(abstract)\s*[:.]?\s*", "", abstract, flags=re.IGNORECASE)
+    abstract = re.sub(r"(?<=[.!?\)\]\"'”’])\d+$", "", abstract)
+    return abstract
+
+
+def _node(
+    *,
+    nid: str,
+    kind: str,
+    short: str,
+    title: str,
+    detail: str,
+    step_added: int,
+    pulse: bool,
+) -> dict[str, Any]:
+    meta = KIND_META.get(kind, KIND_META["citing"])
+    return {
+        "id": nid,
+        "kind": kind,
+        "label": canvas_label(short),
+        "title": _clean(title) or short,
+        "detail": _clean(detail),
+        "step_added": step_added,
+        "pulse": pulse,
+        "color": meta["fill"],
+        "fill": meta["fill"],
+        "ring": meta["ring"],
+        "text": meta["text"],
+        "r": meta["r"],
+        "size": meta["r"],
+        "type_label": meta["type_label"],
+    }
+
+
+def _collect_citing(paper_dir: Optional[Path], limit: int = 6) -> list[dict[str, str]]:
+    if not paper_dir:
+        return []
+    out: list[dict[str, str]] = []
+    seen: set[str] = set()
+    contrib = _load_json(paper_dir / "usage_contributions.json") or {}
+    items = contrib.get("contributions") if isinstance(contrib, dict) else None
+    if isinstance(items, list):
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            cid = str(item.get("citing_paper_id") or "").strip()
+            title = _clean(str(item.get("citing_title") or "Citing paper"))
+            if not cid or cid in seen:
+                continue
+            seen.add(cid)
+            out.append(
+                {
+                    "id": f"citing:{cid}",
+                    "title": title,
+                    "detail": _clean(
+                        str(item.get("paper_claim") or item.get("claim") or item.get("evidence_span") or "")
+                    ),
+                    "label_tag": item.get("label") or "",
+                }
+            )
+            if len(out) >= limit:
+                return out
+    return out
+
+
+def _collect_clusters(paper_dir: Optional[Path], limit: int = 4) -> list[dict[str, str]]:
+    if not paper_dir:
+        return []
+    discovery = _load_json(paper_dir / "usage_discovery_from_contributions.json") or {}
+    clusters = discovery.get("clusters") if isinstance(discovery, dict) else None
+    out: list[dict[str, str]] = []
+    if not isinstance(clusters, list):
+        return out
+    for item in clusters[:limit]:
+        if not isinstance(item, dict):
+            continue
+        cid = str(item.get("cluster_id") or f"C{len(out) + 1}")
+        title = _clean(
+            str(item.get("representative_claim") or item.get("cluster_title") or f"Theme {cid}")
+        )
+        out.append(
+            {
+                "id": f"cluster:{cid}",
+                "cluster_id": cid,
+                "title": title,
+                "detail": _clean(str(item.get("merge_rationale") or f"{item.get('count', '')} contribution instances")),
+            }
+        )
+    return out
+
+
+def _collect_annotation(payload: Optional[dict]) -> tuple[list[dict], list[dict], list[dict]]:
+    claims: list[dict] = []
+    ingredients: list[dict] = []
+    studies: list[dict] = []
+    if not isinstance(payload, dict):
+        return claims, ingredients, studies
+    for claim in (payload.get("claims") or [])[:4]:
+        if not isinstance(claim, dict):
+            continue
+        claim_id = str(claim.get("claim_id") or f"C{len(claims) + 1}")
+        title = _clean(str(claim.get("rewritten_claim") or claim.get("text") or claim_id))
+        claims.append(
+            {
+                "id": f"claim:{claim_id}",
+                "claim_id": claim_id,
+                "cluster_id": str(claim.get("cluster_id") or ""),
+                "title": title,
+                "detail": _clean(str(claim.get("decision") or "")),
+            }
+        )
+        for ing in (claim.get("ingredients") or [])[:3]:
+            if not isinstance(ing, dict):
+                continue
+            iid = str(ing.get("ingredient_id") or f"{claim_id}.I{len(ingredients) + 1}")
+            ann = ing.get("canonical_annotation") if isinstance(ing.get("canonical_annotation"), dict) else {}
+            ingredients.append(
+                {
+                    "id": f"ing:{iid}",
+                    "ingredient_id": iid,
+                    "claim_id": claim_id,
+                    "title": _clean(str(ing.get("ingredient") or iid)),
+                    "detail": _clean(
+                        str((ann or {}).get("contribution") or (ann or {}).get("rationale") or "")
+                    ),
+                    "role": _clean(str((ann or {}).get("role") or "")),
+                }
+            )
+            g = ing.get("canonical_grounding") if isinstance(ing.get("canonical_grounding"), dict) else None
+            if g:
+                sid = str(g.get("paper_id") or g.get("ref_id") or g.get("ref_title") or iid)
+                studies.append(
+                    {
+                        "id": f"study:{sid}",
+                        "ingredient_id": iid,
+                        "title": _clean(str(g.get("ref_title") or g.get("ref_id") or "Prior study")),
+                        "detail": _clean(str(g.get("ref_authors") or g.get("ref_year") or "")),
+                    }
+                )
+    seen: set[str] = set()
+    uniq: list[dict] = []
+    for s in studies:
+        if s["id"] in seen:
+            continue
+        seen.add(s["id"])
+        uniq.append(s)
+    return claims, ingredients, uniq[:6]
+
+
+def build_graph_model(
+    *,
+    paper_dir: Optional[Path],
+    payload: Optional[dict],
+    visible_step: int,
+    pulse_step: int = 0,
+    caption: str = "",
+) -> dict[str, Any]:
+    step = max(0, min(8, int(visible_step or 0)))
+    nodes: list[dict[str, Any]] = []
+    edges: list[dict[str, Any]] = []
+
+    if step >= 1:
+        title = _paper_title_from_dir(paper_dir)
+        abstract = _paper_abstract_from_dir(paper_dir)
+        nodes.append(
+            _node(
+                nid="target",
+                kind="target",
+                short="Target",
+                title=title,
+                detail=abstract[:500],
+                step_added=1,
+                pulse=pulse_step == 1,
+            )
+        )
+
+    citing = _collect_citing(paper_dir) if step >= 2 else []
+    if step >= 2:
+        rows = citing or [
+            {"id": f"citing:placeholder:{i}", "title": f"Citing paper {i+1}", "detail": "Waiting for citation artifacts…", "label_tag": ""}
+            for i in range(3)
+        ]
+        for i, item in enumerate(rows):
+            nodes.append(
+                _node(
+                    nid=item["id"],
+                    kind="citing",
+                    short=f"Citing {i + 1}",
+                    title=item["title"],
+                    detail=item.get("detail") or item.get("label_tag") or "",
+                    step_added=2,
+                    pulse=pulse_step in {2, 3, 4, 5, 6},
+                )
+            )
+            edges.append(
+                {
+                    "id": f"e-target-{item['id']}",
+                    "source": "target",
+                    "target": item["id"],
+                    "kind": "cite",
+                    "muted": step < 5,
+                    "pulse": pulse_step in {2, 3, 4, 5},
+                    "step_added": 2,
+                }
+            )
+
+    # Step 7: reuse themes + target contributions arrive together.
+    clusters = _collect_clusters(paper_dir) if step >= 7 else []
+    claims, ingredients, studies = (
+        _collect_annotation(payload) if step >= 7 else ([], [], [])
+    )
+    if step >= 7 and clusters:
+        for item in clusters:
+            cid = item.get("cluster_id") or "?"
+            nodes.append(
+                _node(
+                    nid=item["id"],
+                    kind="cluster",
+                    short=f"Theme {cid}",
+                    title=item["title"],
+                    detail=item.get("detail") or "",
+                    step_added=7,
+                    pulse=pulse_step == 7,
+                )
+            )
+            edges.append(
+                {
+                    "id": f"e-cluster-{item['id']}",
+                    "source": "target",
+                    "target": item["id"],
+                    "kind": "theme",
+                    "pulse": pulse_step == 7,
+                    "muted": False,
+                    "step_added": 7,
+                }
+            )
+
+    if step >= 7:
+        for item in claims:
+            cid = item.get("claim_id") or "?"
+            nodes.append(
+                _node(
+                    nid=item["id"],
+                    kind="claim",
+                    short=f"Claim {cid}",
+                    title=item["title"],
+                    detail=item.get("detail") or "",
+                    step_added=7,
+                    pulse=pulse_step == 7,
+                )
+            )
+            src = f"cluster:{item.get('cluster_id')}" if item.get("cluster_id") else "target"
+            if not any(n["id"] == src for n in nodes):
+                src = "target"
+            edges.append(
+                {
+                    "id": f"e-claim-{item['id']}",
+                    "source": src,
+                    "target": item["id"],
+                    "kind": "derive",
+                    "pulse": pulse_step == 7,
+                    "muted": False,
+                    "step_added": 7,
+                }
+            )
+
+    # Step 8: enabling contributions + prior studies.
+    if step >= 8:
+        for i, item in enumerate(ingredients):
+            nodes.append(
+                _node(
+                    nid=item["id"],
+                    kind="ingredient",
+                    short=f"Enable {i + 1}",
+                    title=item["title"],
+                    detail=" · ".join(x for x in [item.get("role") or "", item.get("detail") or ""] if x),
+                    step_added=8,
+                    pulse=pulse_step == 8,
+                )
+            )
+            src = f"claim:{item.get('claim_id')}"
+            if any(n["id"] == src for n in nodes):
+                edges.append(
+                    {
+                        "id": f"e-ing-{item['id']}",
+                        "source": src,
+                        "target": item["id"],
+                        "kind": "enable",
+                        "pulse": pulse_step == 8,
+                        "muted": False,
+                        "step_added": 8,
+                    }
+                )
+        for i, item in enumerate(studies):
+            nodes.append(
+                _node(
+                    nid=item["id"],
+                    kind="study",
+                    short=f"Prior {i + 1}",
+                    title=item["title"],
+                    detail=item.get("detail") or "",
+                    step_added=8,
+                    pulse=pulse_step == 8,
+                )
+            )
+            src = f"ing:{item.get('ingredient_id')}"
+            if any(n["id"] == src for n in nodes):
+                edges.append(
+                    {
+                        "id": f"e-study-{item['id']}",
+                        "source": src,
+                        "target": item["id"],
+                        "kind": "ground",
+                        "pulse": pulse_step == 8,
+                        "muted": False,
+                        "step_added": 8,
+                    }
+                )
+
+    if step <= 0:
+        phase_caption = "Waiting to run"
+    elif pulse_step:
+        phase_caption = STEP_COPY.get(pulse_step, "")
+    elif step >= 8:
+        phase_caption = "Workflow complete"
+    else:
+        phase_caption = caption or STEP_COPY.get(step, "")
+
+    return {
+        "step": step,
+        "pulse_step": pulse_step,
+        "caption": phase_caption,
+        "nodes": nodes,
+        "edges": edges,
+        "backend": "memory",
+    }
+
+
+def _graph_payload(model: dict[str, Any]) -> dict[str, Any]:
+    """Serialize a graph model into the payload the canvas shell consumes."""
+    nodes_in = model.get("nodes") or []
+    edges_in = model.get("edges") or []
+
+    nodes_js = []
+    for n in nodes_in:
+        kind = str(n.get("kind") or "citing")
+        meta = KIND_META.get(kind, KIND_META["citing"])
+        nodes_js.append(
+            {
+                "id": n["id"],
+                "label": n.get("label") or "",
+                "kind": kind,
+                "fill": n.get("fill") or meta["fill"],
+                "ring": n.get("ring") or meta["ring"],
+                "text": n.get("text") or meta["text"],
+                "r": float(n.get("r") or meta["r"]),
+                "pulse": bool(n.get("pulse")),
+                "fullTitle": n.get("title") or "",
+                "detail": n.get("detail") or "",
+                "typeLabel": n.get("type_label") or meta["type_label"],
+            }
+        )
+    edges_js = []
+    for e in edges_in:
+        edges_js.append(
+            {
+                "id": e.get("id"),
+                "source": e.get("source"),
+                "target": e.get("target"),
+                "pulse": bool(e.get("pulse")),
+                "muted": bool(e.get("muted")),
+            }
+        )
+    return {
+        "nodes": nodes_js,
+        "edges": edges_js,
+        "kindMeta": _KIND_META_JS,
+        "kindOrder": _KIND_ORDER,
+    }
+
+
+def courier_html(payload: dict[str, Any]) -> str:
+    """Tiny invisible frame that posts a graph model into the persistent shell.
+
+    Runs in its own Streamlit component iframe, reaches the parent document, and
+    postMessages the model to the graph iframe — so the graph updates in place
+    instead of the whole component being re-emitted (which reloads it).
+    """
+    model_str = json.dumps(payload)
+    embed = json.dumps(model_str).replace("</", "<\\/")
+    return (
+        "<!DOCTYPE html><html><head><meta charset=\"utf-8\" /></head><body>"
+        "<script>"
+        "(function(){"
+        "var model=JSON.parse(" + embed + ");"
+        "function post(){try{var f=window.parent.document.querySelectorAll('iframe');"
+        "for(var i=0;i<f.length;i++){try{f[i].contentWindow.postMessage({type:'scipaths-graph',model:model},'*');}catch(e){}}}catch(e){}}"
+        "post();var n=0;var t=setInterval(function(){n++;post();if(n>10)clearInterval(t);},160);"
+        "})();"
+        "</script></body></html>"
+    )
+
+
+def graph_shell_html(height: int = 520) -> str:
+    """Stable, model-free canvas shell. Data arrives via postMessage (incremental).
+
+    The HTML is constant for a given height, so Streamlit reuses the same iframe
+    across reruns instead of remounting it. The graph is populated / grown by
+    ``courier_html`` messages.
+    """
+    payload = json.dumps(
+        {"nodes": [], "edges": [], "kindMeta": _KIND_META_JS, "kindOrder": _KIND_ORDER}
+    )
+    row_h = max(300, height - 30)
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet" />
+  <style>
+    html, body {{ margin:0; padding:0; background:transparent; font-family: Inter, system-ui, sans-serif; color:#13201d; }}
+    * {{ box-sizing:border-box; }}
+    .wrap {{ border-top:1px solid rgba(19,32,29,0.12); padding-top:0.5rem; }}
+    .kicker {{ font-size:0.68rem; font-weight:700; letter-spacing:0.12em; text-transform:uppercase; color:#6a7a74; margin-bottom:0.4rem; }}
+    .row {{ display:flex; gap:0.6rem; align-items:stretch; height:{row_h}px; }}
+    /* ── Control rail ── */
+    .rail {{
+      width:210px; flex:0 0 210px; display:flex; flex-direction:column; overflow:hidden;
+      border:1px solid rgba(15,23,42,0.10); border-radius:11px; background:#ffffff;
+    }}
+    .rail-head {{ padding:0.55rem 0.75rem; border-bottom:1px solid rgba(15,23,42,0.08);
+      font-size:0.66rem; font-weight:700; letter-spacing:0.09em; text-transform:uppercase; color:#6a7a74; }}
+    .rail-body {{ flex:1; overflow-y:auto; padding:0.6rem 0.65rem; }}
+    .rail-search {{ position:relative; margin-bottom:0.7rem; }}
+    .rail-search input {{
+      width:100%; height:30px; padding:0 1.6rem 0 0.6rem; font-size:0.76rem; font-family:inherit;
+      border:1px solid rgba(15,23,42,0.16); border-radius:7px; outline:none; color:#13201d;
+    }}
+    .rail-search input:focus {{ border-color:#4F6EF7; box-shadow:0 0 0 3px rgba(79,110,247,0.16); }}
+    .rail-search .clr {{ position:absolute; right:6px; top:50%; transform:translateY(-50%);
+      border:0; background:transparent; color:#94a3b8; cursor:pointer; font-size:0.9rem; line-height:1; }}
+    .rail-actions {{ display:grid; grid-template-columns:1fr 1fr; gap:0.35rem; margin-bottom:0.75rem; }}
+    .rail-actions button {{
+      font-size:0.66rem; font-weight:600; font-family:inherit; padding:0.34rem 0.3rem; cursor:pointer;
+      border:1px solid rgba(15,23,42,0.16); border-radius:7px; background:#fff; color:#13201d;
+    }}
+    .rail-actions button:hover {{ background:#f4f6fb; }}
+    .rail-actions button.on {{ border-color:#4F6EF7; background:#eef1fe; color:#1E3A8A; }}
+    .sec-head {{ display:flex; align-items:center; justify-content:space-between; margin:0 0 0.35rem 0.15rem; }}
+    .sec-head .lbl {{ font-size:0.63rem; font-weight:700; letter-spacing:0.07em; text-transform:uppercase; color:#94a3b8; }}
+    .sec-head .acts {{ display:flex; gap:0.45rem; }}
+    .sec-head .acts button {{ border:0; background:transparent; font-size:0.62rem; font-weight:600; color:#4F6EF7; cursor:pointer; padding:0; }}
+    .cat {{
+      width:100%; display:flex; align-items:center; gap:0.5rem; padding:0.28rem 0.35rem; cursor:pointer;
+      border:0; background:transparent; border-radius:6px; text-align:left; font-family:inherit;
+    }}
+    .cat:hover {{ background:#f4f6fb; }}
+    .cat .box {{ width:13px; height:13px; flex:0 0 13px; border-radius:3px; border:1.5px solid rgba(15,23,42,0.28);
+      display:flex; align-items:center; justify-content:center; color:#fff; font-size:9px; }}
+    .cat .box.on {{ background:#4F6EF7; border-color:#4F6EF7; }}
+    .cat .dot {{ width:12px; height:12px; flex:0 0 12px; border-radius:50%; }}
+    .cat .name {{ flex:1; font-size:0.74rem; color:#334155; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }}
+    .cat .cnt {{ font-size:0.68rem; color:#94a3b8; font-variant-numeric:tabular-nums; }}
+    .cat.off .name {{ color:#b6c0cc; text-decoration:line-through; }}
+    .cat.off .dot {{ opacity:0.35; }}
+    /* ── Stage ── */
+    .stage {{
+      position:relative; flex:1; min-width:0; border-radius:11px; overflow:hidden;
+      background:#fafbfd; border:1px solid rgba(15,23,42,0.08);
+    }}
+    canvas {{ display:block; width:100%; height:100%; cursor:grab; }}
+    canvas.dragging {{ cursor:grabbing; }}
+    .card {{
+      position:absolute; left:12px; top:12px; width:250px; max-height:calc(100% - 24px);
+      overflow:auto; background:rgba(255,255,255,0.97); border:1px solid rgba(15,23,42,0.10);
+      border-radius:10px; padding:0.7rem 0.75rem; box-shadow:0 10px 30px rgba(15,23,42,0.10);
+      display:none; z-index:2;
+    }}
+    .card.open {{ display:block; }}
+    .card-type {{ font-size:0.66rem; font-weight:700; letter-spacing:0.08em; text-transform:uppercase; color:#4F6EF7; margin-bottom:0.25rem; }}
+    .card-title {{ font-size:0.9rem; font-weight:700; line-height:1.3; margin:0 0 0.4rem 0; color:#13201d; }}
+    .card-detail {{ font-size:0.78rem; line-height:1.45; color:#3d4f4a; margin:0; white-space:pre-wrap; }}
+    .card-close {{ position:absolute; right:8px; top:6px; border:0; background:transparent; color:#6a7a74; font-size:1rem; cursor:pointer; }}
+    .hint {{ position:absolute; left:10px; bottom:8px; font-size:0.66rem; color:#94a3b8; pointer-events:none;
+      background:rgba(255,255,255,0.9); padding:0.2rem 0.45rem; border-radius:6px; }}
+  </style>
+</head>
+<body>
+  <div class="wrap">
+    <div class="kicker">Workflow</div>
+    <div class="row">
+      <aside class="rail">
+        <div class="rail-head">Graph controls</div>
+        <div class="rail-body">
+          <div class="rail-search">
+            <input id="q" type="text" placeholder="Highlight nodes" autocomplete="off" />
+            <button class="clr" id="qClr" title="Clear" style="display:none">×</button>
+          </div>
+          <div class="rail-actions">
+            <button id="fitBtn">Fit view</button>
+            <button id="resetBtn">Reset</button>
+          </div>
+          <div class="sec-head">
+            <span class="lbl">Node categories</span>
+            <span class="acts">
+              <button id="allBtn">All</button>
+              <button id="noneBtn">None</button>
+            </span>
+          </div>
+          <div id="cats"></div>
+        </div>
+      </aside>
+      <div class="stage" id="stage">
+        <canvas id="cv"></canvas>
+        <div id="card" class="card">
+          <button class="card-close" id="closeBtn" aria-label="Close">×</button>
+          <div class="card-type" id="cardType"></div>
+          <div class="card-title" id="cardTitle"></div>
+          <p class="card-detail" id="cardDetail"></p>
+        </div>
+        <div class="hint">Drag to move · scroll to zoom · click a node for details</div>
+      </div>
+    </div>
+  </div>
+  <script>
+    const payload = {payload};
+    const KM = payload.kindMeta || {{}};
+    const stage = document.getElementById('stage');
+    const canvas = document.getElementById('cv');
+    const ctx = canvas.getContext('2d');
+    const card = document.getElementById('card');
+    const cardType = document.getElementById('cardType');
+    const cardTitle = document.getElementById('cardTitle');
+    const cardDetail = document.getElementById('cardDetail');
+    document.getElementById('closeBtn').onclick = () => {{ selected = null; card.classList.remove('open'); }};
+
+    let W = 0, H = 0, dpr = 1;
+    function resize() {{
+      dpr = window.devicePixelRatio || 1;
+      W = stage.clientWidth; H = stage.clientHeight;
+      canvas.width = Math.floor(W * dpr);
+      canvas.height = Math.floor(H * dpr);
+      canvas.style.width = W + 'px';
+      canvas.style.height = H + 'px';
+    }}
+    resize();
+    window.addEventListener('resize', () => {{ resize(); }});
+
+    // ── Position memory across reruns (Mina keeps xy so the graph grows, not jumps).
+    const memKey = 'scipaths-mina-pos';
+    let saved = {{}};
+    try {{ saved = JSON.parse(sessionStorage.getItem(memKey) || '{{}}'); }} catch (e) {{ saved = {{}}; }}
+
+    // Mutable graph state — grown in place by incremental postMessage updates.
+    let nodes = [];
+    const byId = new Map();
+    let edges = [];
+    let target = null;
+
+    // ── Filter / search state ──
+    const hiddenKinds = new Set();
+    let query = '';
+    const isVisible = (n) => !hiddenKinds.has(n.kind);
+
+    // ── Write pulse — Mina: staggered one-shot expanding rings + travelling dashes.
+    const PULSE_RING_MS = 1200;
+    const PULSE_RING_OFFSETS = [0, 0.35];
+    const PULSE_LIFETIME_MS = PULSE_RING_MS * (1 + Math.max(...PULSE_RING_OFFSETS));
+    const PULSE_DASH = [7, 5];
+    let pulseNodeIds = new Set();
+    let pulseEdgeIds = new Set();
+    let pulseStart = 0;
+
+    // ── View transform (zoom + pan), Mina-style ──
+    let zoom = 0.95;
+    let panX = (W / 2) * (1 - zoom);
+    let panY = (H / 2) * (1 - zoom);
+    let alpha = 1;
+    const toWorld = (px, py) => ({{ x: (px - panX) / zoom, y: (py - panY) / zoom }});
+
+    let dragNode = null, panning = false, moved = false;
+    let last = {{ x: 0, y: 0 }};
+    let selected = null;
+
+    function persist() {{
+      const out = {{}};
+      nodes.forEach(n => {{ out[n.id] = {{ x: n.x, y: n.y }}; }});
+      try {{ sessionStorage.setItem(memKey, JSON.stringify(out)); }} catch (e) {{}}
+    }}
+
+    function nodeAt(px, py) {{
+      const w = toWorld(px, py);
+      for (let i = nodes.length - 1; i >= 0; i--) {{
+        const n = nodes[i];
+        if (!isVisible(n)) continue;
+        const dx = n.x - w.x, dy = n.y - w.y;
+        if (dx * dx + dy * dy <= (n.r + 5) * (n.r + 5)) return n;
+      }}
+      return null;
+    }}
+    const getPos = (ev) => {{ const r = canvas.getBoundingClientRect(); return {{ x: ev.clientX - r.left, y: ev.clientY - r.top }}; }};
+
+    canvas.addEventListener('mousedown', (ev) => {{
+      const p = getPos(ev); const n = nodeAt(p.x, p.y); moved = false;
+      if (n) {{ dragNode = n; alpha = Math.max(alpha, 0.4); }} else {{ panning = true; }}
+      last = p; canvas.classList.add('dragging');
+    }});
+    canvas.addEventListener('mousemove', (ev) => {{
+      const p = getPos(ev);
+      if (dragNode) {{ const w = toWorld(p.x, p.y); dragNode.x = w.x; dragNode.y = w.y; dragNode.vx = 0; dragNode.vy = 0; moved = true; }}
+      else if (panning) {{ panX += p.x - last.x; panY += p.y - last.y; moved = true; }}
+      else {{ canvas.style.cursor = nodeAt(p.x, p.y) ? 'pointer' : 'grab'; }}
+      last = p;
+    }});
+    window.addEventListener('mouseup', (ev) => {{
+      if (ev.target === canvas && !moved) {{
+        const p = getPos(ev); const n = nodeAt(p.x, p.y);
+        if (n) {{
+          selected = n;
+          cardType.textContent = n.typeLabel || n.kind || 'Node';
+          cardTitle.textContent = n.fullTitle || n.label || '';
+          cardDetail.textContent = n.detail || 'No additional detail for this node.';
+          card.classList.add('open');
+        }} else {{ selected = null; card.classList.remove('open'); }}
+      }}
+      if (dragNode) persist();
+      dragNode = null; panning = false; canvas.classList.remove('dragging');
+    }});
+    canvas.addEventListener('wheel', (ev) => {{
+      ev.preventDefault();
+      const p = getPos(ev); const before = toWorld(p.x, p.y);
+      const factor = ev.deltaY < 0 ? 1.1 : 0.9;
+      zoom = Math.max(0.3, Math.min(2.5, zoom * factor));
+      panX = p.x - before.x * zoom; panY = p.y - before.y * zoom;
+    }}, {{ passive: false }});
+
+    // ── Force layout — Mina model: inverse-square repulsion + springs +
+    //    center gravity + collision relaxation + annealing alpha (looser). ──
+    function tick() {{
+      const N = nodes.length;
+      for (let i = 0; i < N; i++) {{
+        for (let j = i + 1; j < N; j++) {{
+          const a = nodes[i], b = nodes[j];
+          let dx = b.x - a.x, dy = b.y - a.y;
+          let d2 = dx * dx + dy * dy; if (d2 < 1) d2 = 1;
+          const d = Math.sqrt(d2);
+          const force = (5600 * alpha) / d2;
+          dx /= d; dy /= d;
+          if (a !== dragNode && !a.fixed) {{ a.vx -= dx * force; a.vy -= dy * force; }}
+          if (b !== dragNode && !b.fixed) {{ b.vx += dx * force; b.vy += dy * force; }}
+        }}
+      }}
+      edges.forEach(e => {{
+        const a = byId.get(e.source), b = byId.get(e.target);
+        if (!a || !b) return;
+        const ideal = 155;
+        let dx = b.x - a.x, dy = b.y - a.y;
+        const d = Math.max(1, Math.sqrt(dx * dx + dy * dy));
+        const force = ((d - ideal) / d) * 0.045 * alpha;
+        dx *= force; dy *= force;
+        if (!a.fixed && a !== dragNode) {{ a.vx += dx; a.vy += dy; }}
+        if (!b.fixed && b !== dragNode) {{ b.vx -= dx; b.vy -= dy; }}
+      }});
+      const cx = W / 2, cy = H / 2;
+      nodes.forEach(n => {{
+        if (n.fixed || n === dragNode) return;
+        n.vx += (cx - n.x) * 0.0042 * alpha;
+        n.vy += (cy - n.y) * 0.0042 * alpha;
+        n.vx *= 0.86; n.vy *= 0.86;
+        n.x += n.vx; n.y += n.vy;
+      }});
+      // Hard collision relaxation so nothing overlaps (with label breathing room).
+      for (let i = 0; i < N; i++) {{
+        for (let j = i + 1; j < N; j++) {{
+          const a = nodes[i], b = nodes[j];
+          const dx = b.x - a.x, dy = b.y - a.y;
+          const min = a.r + b.r + 18;
+          const d = Math.sqrt(dx * dx + dy * dy) || 0.01;
+          if (d < min) {{
+            const push = (min - d) / d;
+            const ox = dx * push * 0.5, oy = dy * push * 0.5;
+            if (a !== dragNode && !a.fixed) {{ a.x -= ox; a.y -= oy; }}
+            if (b !== dragNode && !b.fixed) {{ b.x += ox; b.y += oy; }}
+          }}
+        }}
+      }}
+      if (target) {{ target.x = cx; target.y = cy; target.vx = 0; target.vy = 0; }}
+      alpha = Math.max(0.02, alpha * 0.9955);
+      for (const n of nodes) saved[n.id] = {{ x: n.x, y: n.y }};
+    }}
+
+    function draw() {{
+      tick();
+      ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+      ctx.clearRect(0, 0, W, H);
+      ctx.fillStyle = '#fafbfd';
+      ctx.fillRect(0, 0, W, H);
+      ctx.translate(panX, panY);
+      ctx.scale(zoom, zoom);
+
+      const q = query.trim().toLowerCase();
+      const pulseAge = performance.now() - pulseStart;
+      const pulseAlive = pulseAge < PULSE_LIFETIME_MS;
+      const pulseFade = pulseAlive ? 1 - pulseAge / PULSE_LIFETIME_MS : 0;
+
+      // edges
+      edges.forEach(e => {{
+        const a = byId.get(e.source), b = byId.get(e.target);
+        if (!a || !b || !isVisible(a) || !isVisible(b)) return;
+        const pulsing = pulseAlive && pulseEdgeIds.has(e.id);
+        ctx.beginPath();
+        ctx.moveTo(a.x, a.y); ctx.lineTo(b.x, b.y);
+        ctx.strokeStyle = e.muted ? 'rgba(148,163,184,0.30)' : 'rgba(100,116,139,0.42)';
+        ctx.lineWidth = (e.muted ? 1 : 1.4) + (pulsing ? 1.2 * pulseFade : 0);
+        if (pulsing) {{
+          ctx.setLineDash(PULSE_DASH);
+          ctx.lineDashOffset = -((pulseAge / 26) % (PULSE_DASH[0] + PULSE_DASH[1]));
+        }} else {{
+          ctx.setLineDash(e.muted ? [3, 3] : []);
+          ctx.lineDashOffset = 0;
+        }}
+        ctx.stroke();
+        ctx.setLineDash([]); ctx.lineDashOffset = 0;
+      }});
+
+      // nodes — exact Mina draw order
+      nodes.forEach(n => {{
+        if (!isVisible(n)) return;
+        const x = n.x, y = n.y, r = n.r;
+        const isSelected = selected && selected.id === n.id;
+        const dimmed = q.length > 0 && !String(n.label || '').toLowerCase().includes(q);
+        ctx.globalAlpha = dimmed ? 0.15 : 1;
+
+        if (pulseAlive && pulseNodeIds.has(n.id)) {{
+          for (const offset of PULSE_RING_OFFSETS) {{
+            const p = pulseAge / PULSE_RING_MS - offset;
+            if (p <= 0 || p >= 1) continue;
+            ctx.beginPath();
+            ctx.arc(x, y, r + 3 + p * 26, 0, Math.PI * 2);
+            ctx.strokeStyle = n.fill;
+            ctx.globalAlpha = (1 - p) * 0.55;
+            ctx.lineWidth = 2.5 * (1 - p) + 0.5;
+            ctx.stroke();
+          }}
+          ctx.globalAlpha = dimmed ? 0.15 : 1;
+        }}
+
+        if (isSelected) {{
+          ctx.beginPath();
+          ctx.arc(x, y, r + 7, 0, Math.PI * 2);
+          ctx.fillStyle = n.fill + '22'; ctx.fill();
+          ctx.beginPath();
+          ctx.arc(x, y, r + 5, 0, Math.PI * 2);
+          ctx.strokeStyle = n.ring; ctx.lineWidth = 1.5; ctx.stroke();
+        }}
+
+        ctx.beginPath();
+        ctx.arc(x, y, r, 0, Math.PI * 2);
+        ctx.fillStyle = n.fill; ctx.fill();
+        ctx.lineWidth = 2; ctx.strokeStyle = '#fff'; ctx.stroke();
+        ctx.beginPath();
+        ctx.arc(x, y, r + 1.5, 0, Math.PI * 2);
+        ctx.lineWidth = 1.25; ctx.strokeStyle = n.ring; ctx.stroke();
+
+        const raw = String(n.label || '');
+        const label = raw.length > 26 ? raw.slice(0, 25) + '…' : raw;
+        const weight = n.kind === 'target' ? '700 12px' : (n.kind === 'cluster' ? '600 11px' : '500 10px');
+        ctx.font = weight + ' Inter, sans-serif';
+        ctx.textAlign = 'center'; ctx.textBaseline = 'alphabetic';
+        ctx.lineWidth = 3; ctx.strokeStyle = 'rgba(250,251,253,0.9)';
+        ctx.strokeText(label, x, y + r + 13);
+        ctx.fillStyle = n.text;
+        ctx.fillText(label, x, y + r + 13);
+        ctx.globalAlpha = 1;
+      }});
+
+      requestAnimationFrame(draw);
+    }}
+    requestAnimationFrame(draw);
+    setTimeout(persist, 900);
+
+    // ── Fit / reset view ──
+    function fitView() {{
+      const vis = nodes.filter(isVisible);
+      if (!vis.length) return;
+      let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+      vis.forEach(n => {{ minX = Math.min(minX, n.x - n.r); minY = Math.min(minY, n.y - n.r);
+        maxX = Math.max(maxX, n.x + n.r + 20); maxY = Math.max(maxY, n.y + n.r + 20); }});
+      const gw = Math.max(1, maxX - minX), gh = Math.max(1, maxY - minY);
+      zoom = Math.max(0.3, Math.min(1.6, Math.min((W - 40) / gw, (H - 40) / gh)));
+      panX = W / 2 - ((minX + maxX) / 2) * zoom;
+      panY = H / 2 - ((minY + maxY) / 2) * zoom;
+    }}
+    document.getElementById('fitBtn').onclick = fitView;
+    document.getElementById('resetBtn').onclick = () => {{
+      hiddenKinds.clear(); query = ''; document.getElementById('q').value = '';
+      document.getElementById('qClr').style.display = 'none';
+      selected = null; card.classList.remove('open');
+      try {{ sessionStorage.removeItem(memKey); }} catch (e) {{}}
+      alpha = 1; renderCats();
+      const cx = W / 2, cy = H / 2;
+      nodes.forEach((n, i) => {{
+        const a = (i / Math.max(nodes.length, 1)) * Math.PI * 2;
+        n.x = n.id === 'target' ? cx : cx + Math.cos(a) * (90 + Math.random() * 70);
+        n.y = n.id === 'target' ? cy : cy + Math.sin(a) * (90 + Math.random() * 70);
+        n.vx = 0; n.vy = 0;
+      }});
+      zoom = 0.95; panX = (W / 2) * (1 - zoom); panY = (H / 2) * (1 - zoom);
+    }};
+
+    // ── Search ──
+    const qInput = document.getElementById('q');
+    const qClr = document.getElementById('qClr');
+    qInput.addEventListener('input', () => {{ query = qInput.value; qClr.style.display = query ? 'block' : 'none'; }});
+    qClr.onclick = () => {{ query = ''; qInput.value = ''; qClr.style.display = 'none'; }};
+
+    // ── Node category filter rail ──
+    function counts() {{
+      const m = {{}};
+      nodes.forEach(n => {{ m[n.kind] = (m[n.kind] || 0) + 1; }});
+      return m;
+    }}
+    function renderCats() {{
+      const c = counts();
+      const order = (payload.kindOrder || Object.keys(KM)).filter(k => (c[k] || 0) > 0);
+      const host = document.getElementById('cats');
+      host.innerHTML = '';
+      order.forEach(k => {{
+        const meta = KM[k] || {{ fill: '#94a3b8', ring: '#e2e8f0', label: k }};
+        const on = !hiddenKinds.has(k);
+        const btn = document.createElement('button');
+        btn.className = 'cat' + (on ? '' : ' off');
+        btn.innerHTML =
+          '<span class="box' + (on ? ' on' : '') + '">' + (on ? '✓' : '') + '</span>' +
+          '<span class="dot" style="background:' + meta.fill + ';box-shadow:0 0 0 2px ' + meta.ring + '"></span>' +
+          '<span class="name">' + meta.label + '</span>' +
+          '<span class="cnt">' + (c[k] || 0) + '</span>';
+        btn.onclick = () => {{
+          if (hiddenKinds.has(k)) hiddenKinds.delete(k); else hiddenKinds.add(k);
+          alpha = Math.max(alpha, 0.3); renderCats();
+        }};
+        host.appendChild(btn);
+      }});
+    }}
+    document.getElementById('allBtn').onclick = () => {{ hiddenKinds.clear(); alpha = Math.max(alpha, 0.3); renderCats(); }};
+    document.getElementById('noneBtn').onclick = () => {{
+      Object.keys(counts()).forEach(k => hiddenKinds.add(k)); renderCats();
+    }};
+    renderCats();
+
+    // ── Incremental model merge (Mina reveal): add new nodes near a neighbor,
+    //    keep existing positions, pulse writes, drop nodes no longer present. ──
+    let lastSig = '';
+    function applyModel(model) {{
+      if (!model) return;
+      const inNodes = model.nodes || [];
+      const inEdges = model.edges || [];
+      const sig = inNodes.map(n => n.id + (n.pulse ? '*' : '')).join(',') + '|' + inEdges.map(e => e.id).join(',');
+      if (sig === lastSig) return;
+      lastSig = sig;
+      if (model.kindMeta) Object.assign(KM, model.kindMeta);
+      if (model.kindOrder) payload.kindOrder = model.kindOrder;
+      const incIds = new Set(inNodes.map(n => n.id));
+      const adj = {{}};
+      inEdges.forEach(e => {{ (adj[e.source] = adj[e.source] || []).push(e.target); (adj[e.target] = adj[e.target] || []).push(e.source); }});
+      const pN = new Set(), pE = new Set();
+      let added = false;
+      inNodes.forEach(n => {{
+        let nd = byId.get(n.id);
+        if (nd) {{
+          nd.label = n.label; nd.kind = n.kind; nd.fill = n.fill; nd.ring = n.ring;
+          nd.text = n.text; nd.r = n.r; nd.typeLabel = n.typeLabel; nd.fullTitle = n.fullTitle; nd.detail = n.detail;
+          if (n.pulse) pN.add(n.id);
+        }} else {{
+          const prev = saved[n.id];
+          let x, y;
+          if (prev) {{ x = prev.x; y = prev.y; }}
+          else {{
+            const nb = (adj[n.id] || []).map(id => byId.get(id)).find(Boolean);
+            const base = nb ? {{ x: nb.x, y: nb.y }} : {{ x: W / 2, y: H / 2 }};
+            const a = Math.random() * Math.PI * 2, rr = 70 + Math.random() * 60;
+            x = base.x + Math.cos(a) * rr; y = base.y + Math.sin(a) * rr;
+          }}
+          nd = Object.assign({{}}, n, {{ x, y, vx: 0, vy: 0, fixed: n.id === 'target' }});
+          nodes.push(nd); byId.set(n.id, nd); added = true; pN.add(n.id);
+        }}
+      }});
+      for (let i = nodes.length - 1; i >= 0; i--) {{
+        if (!incIds.has(nodes[i].id)) {{ byId.delete(nodes[i].id); nodes.splice(i, 1); }}
+      }}
+      edges = inEdges.filter(e => byId.get(e.source) && byId.get(e.target)).map(e => Object.assign({{}}, e));
+      edges.forEach(e => {{ if (e.pulse) pE.add(e.id); }});
+      pulseNodeIds = pN; pulseEdgeIds = pE;
+      if (pN.size || pE.size || added) {{ pulseStart = performance.now(); alpha = Math.max(alpha, 0.55); }}
+      target = byId.get('target'); if (target) target.fixed = true;
+      renderCats();
+    }}
+    window.addEventListener('message', (e) => {{
+      const d = e.data;
+      if (d && d.type === 'scipaths-graph') applyModel(d.model);
+    }});
+    if (payload.nodes && payload.nodes.length) applyModel(payload);
+  </script>
+</body>
+</html>"""
+
+
+def sync_and_load_graph(run_id: str, model: dict[str, Any]) -> dict[str, Any]:
+    """Push cumulative graph to Neo4j and read it back for rendering."""
+    if not run_id or neo4j_store is None:
+        model = dict(model)
+        model["backend"] = "memory"
+        return model
+    nodes = model.get("nodes") or []
+    edges = model.get("edges") or []
+    ok = neo4j_store.upsert_graph(run_id, nodes, edges)
+    if not ok:
+        model = dict(model)
+        model["backend"] = "memory"
+        return model
+    fetched = neo4j_store.fetch_graph(run_id)
+    if not fetched:
+        model = dict(model)
+        model["backend"] = "neo4j-write"
+        return model
+    # Preserve caption/step and enrich fetched nodes with Mina colors.
+    out_nodes = []
+    for n in fetched.get("nodes") or []:
+        kind = str(n.get("kind") or "citing")
+        meta = KIND_META.get(kind, KIND_META["citing"])
+        out_nodes.append(
+            {
+                **n,
+                "type_label": meta["type_label"],
+                "color": n.get("color") or meta["fill"],
+                "fill": n.get("fill") or meta["fill"],
+                "ring": n.get("ring") or meta["ring"],
+                "text": n.get("text") or meta["text"],
+                "r": n.get("r") or meta["r"],
+                "size": n.get("size") or meta["r"],
+            }
+        )
+    return {
+        "step": model.get("step"),
+        "pulse_step": model.get("pulse_step"),
+        "caption": model.get("caption"),
+        "nodes": out_nodes,
+        "edges": fetched.get("edges") or [],
+        "backend": "neo4j",
+    }
+
+
+def build_synced_model(
+    *,
+    paper_dir: Optional[Path],
+    payload: Optional[dict],
+    events: list[str],
+    run_id: str = "",
+) -> dict[str, Any]:
+    """Build the cumulative graph model for the given events and sync to Neo4j."""
+    visible = visible_step_from_events(events)
+    pulse = pulse_step_from_events(events)
+    joined = " ".join(str(e) for e in (events or []))
+    if "Pipeline completed successfully." in joined or (
+        "Step 8 complete" in joined or ("annotation" in joined.lower() and "complete" in joined.lower())
+    ):
+        if visible >= 8:
+            pulse = 0
+            visible = 8
+
+    model = build_graph_model(
+        paper_dir=paper_dir,
+        payload=payload,
+        visible_step=visible,
+        pulse_step=pulse,
+    )
+    return sync_and_load_graph(run_id or "default", model)
+
+
+def render_graph_shell(placeholder, *, height: int = 520) -> None:
+    """Mount the persistent, model-free canvas shell (constant HTML → no remount)."""
+    html = graph_shell_html(height)
+    if placeholder is None:
+        st.iframe(html, height=height)
+        return
+    with placeholder.container():
+        st.iframe(html, height=height)
+
+
+def push_graph_update(courier_slot, model: dict[str, Any], *, height: int = 0) -> None:
+    """Push a model into the mounted shell via an invisible courier frame."""
+    html = courier_html(_graph_payload(model))
+    if courier_slot is None:
+        st.components.v1.html(html, height=height)
+        return
+    with courier_slot.container():
+        st.components.v1.html(html, height=height)
+
+
+def render_workflow_into(
+    placeholder,
+    *,
+    paper_dir: Optional[Path],
+    payload: Optional[dict],
+    events: list[str],
+    run_id: str = "",
+    height: int = 520,
+) -> None:
+    """Back-compat single-slot render: mount shell then push once into it."""
+    render_graph_shell(placeholder, height=height)
+    model = build_synced_model(
+        paper_dir=paper_dir, payload=payload, events=events, run_id=run_id
+    )
+    push_graph_update(None, model)

replay_traces/2208.00329/input_ids.json

@@ -0,0 +1,7 @@
+[
+  {
+    "id": "2208.00329",
+    "title": "",
+    "id_type": "ArXiv"
+  }
+]

replay_traces/2208.00329/logs/step_01.log

@@ -0,0 +1,18 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_01_fetch/fetch_metadata.py --ids /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/input_ids.json --outdir /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+
+/Users/dingzifeng/SciFy-UMBC/demo_2026_07/src/step_01_fetch/fetch_metadata.py:95: DeprecationWarning: The 'Search.results' method is deprecated, use 'Client.results' instead
+  paper = next(search.results())
+/Users/dingzifeng/SciFy-UMBC/demo_2026_07/src/step_01_fetch/fetch_metadata.py:124: DeprecationWarning: Python 3.14 will, by default, filter extracted tar archives and reject files or modify their metadata. Use the filter argument to control this behavior.
+  tar.extractall(path=source_dir)
+[INFO] Using ID list from /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/input_ids.json
+[INFO] Output will be saved to /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[DEBUG] fetch_one_acl_id: id=2208.00329 id_type=ArXiv title_len=0 s2_key_present=yes s2_key_len=44
+[DEBUG] wrote metadata to /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers/2208.00329/paper_metadata.json
+[INFO] Wrote combined BibTeX to /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers/2208.00329/references.bib
+[INFO] Processed LaTeX for 2208.00329 at /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers/2208.00329/processed_main.tex
+[WARN] 429 Too Many Requests → retrying in 1.50s
+[WARN] 429 Too Many Requests → retrying in 2.15s
+[WARN] 429 Too Many Requests → retrying in 4.24s
+[WARN] 429 Too Many Requests → retrying in 8.26s
+[SUCCESS]
+done in 28.508277893066406 s

replay_traces/2208.00329/logs/step_02.log

@@ -0,0 +1,5 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_02_mark_citations/replace_citation_markers.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[OK] 2208.00329: updated 19 contexts over 20
+[SUMMARY] total_updated=19 over 20; skipped_incomplete=0

replay_traces/2208.00329/logs/step_03.log

@@ -0,0 +1,4 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_03_usage_contexts/build_usage_contexts.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers --out-name usage_contexts.json
+
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[OK] 2208.00329: wrote usage_contexts.json (20 contexts from 7 citations)

replay_traces/2208.00329/logs/step_04.log

@@ -0,0 +1,6 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_04_label_citations/label_citation_functions.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers --model-path Deep-Citation/Workspace/acl_scicite_wksp_trl/best_model.pt --model-data-dir Deep-Citation/Data --model-class-def Deep-Citation/Data/class_def.json --model-lm scibert --device cpu
+
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+Number of data instance: 1941
+[LABELED] 2208.00329
+[SUMMARY] labeled=1, skipped=0, missing_usage=0, empty_contexts=0

replay_traces/2208.00329/logs/step_05.log

@@ -0,0 +1,14 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_05_verify_uses_extends/verify_uses_extends.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers --k 0 --batch-size 25
+
+/Users/dingzifeng/SciFy-UMBC/demo_2026_07/src/common/llm_client.py:4: FutureWarning: 
+
+All support for the `google.generativeai` package has ended. It will no longer be receiving 
+updates or bug fixes. Please switch to the `google.genai` package as soon as possible.
+See README for more details:
+
+https://github.com/google-gemini/deprecated-generative-ai-python/blob/main/README.md
+
+  import google.generativeai as genai
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[VERIFIED] 2208.00329
+[SUMMARY] verified=1, skipped=0, missing_labels=0, no_candidates=0

replay_traces/2208.00329/logs/step_06.log

@@ -0,0 +1,7 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_06_extract_paragraphs/extract_arxiv_paragraphs.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+
+/Users/dingzifeng/SciFy-UMBC/demo_2026_07/src/step_06_extract_paragraphs/extract_arxiv_paragraphs.py:47: DeprecationWarning: Python 3.14 will, by default, filter extracted tar archives and reject files or modify their metadata. Use the filter argument to control this behavior.
+  tar.extractall(path)
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[PROCESSED] 2208.00329
+[SUMMARY] processed=1, skipped=0, missing_usage=0, missing_verified=0, empty_citing=0

replay_traces/2208.00329/logs/step_07.log

@@ -0,0 +1,28 @@
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_07_extract_and_refine/extract_contributions_from_citations.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+
+/Users/dingzifeng/SciFy-UMBC/demo_2026_07/src/common/llm_client.py:4: FutureWarning: 
+
+All support for the `google.generativeai` package has ended. It will no longer be receiving 
+updates or bug fixes. Please switch to the `google.genai` package as soon as possible.
+See README for more details:
+
+https://github.com/google-gemini/deprecated-generative-ai-python/blob/main/README.md
+
+  import google.generativeai as genai
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[LABELED] 2208.00329
+[SUMMARY] labeled=1, skipped=0, missing_verified=0, missing_arxiv_paragraphs=0, no_confirmed=0
+$ /Users/dingzifeng/SciFy-UMBC/demo_2026_07/.venv/bin/python src/step_07_extract_and_refine/refine_and_filter_clusters_llm.py --root /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers --inplace --overwrite
+
+/Users/dingzifeng/SciFy-UMBC/demo_2026_07/src/common/llm_client.py:4: FutureWarning: 
+
+All support for the `google.generativeai` package has ended. It will no longer be receiving 
+updates or bug fixes. Please switch to the `google.genai` package as soon as possible.
+See README for more details:
+
+https://github.com/google-gemini/deprecated-generative-ai-python/blob/main/README.md
+
+  import google.generativeai as genai
+[INFO] Found 1 paper dirs under /Users/dingzifeng/SciFy-UMBC/demo_2026_07/hf_space/runs/replay_build/job_1785099279_8df5ecbb/processed_papers
+[REFINED] 2208.00329
+[SUMMARY] refined=1, skipped=0, missing_inputs=0, empty_clusters=0

replay_traces/2208.00329/processed_papers/2208.00329/paper_metadata.json

@@ -0,0 +1,55 @@
+[
+  {
+    "paperId": "e894fb15054d3bc9659060406a12dfd1055ae32e",
+    "externalIds": {
+      "DBLP": "journals/corr/abs-2208-00329",
+      "ArXiv": "2208.00329",
+      "DOI": "10.1162/tacl_a_00600",
+      "CorpusId": 251223896
+    },
+    "url": "https://www.semanticscholar.org/paper/e894fb15054d3bc9659060406a12dfd1055ae32e",
+    "title": "PASTA: A Dataset for Modeling PArticipant STAtes in Narratives",
+    "venue": "Transactions of the Association for Computational Linguistics",
+    "year": 2022,
+    "referenceCount": 59,
+    "citationCount": 7,
+    "openAccessPdf": {
+      "url": "https://direct.mit.edu/tacl/article-pdf/doi/10.1162/tacl_a_00600/2173956/tacl_a_00600.pdf",
+      "status": "GOLD",
+      "license": "CCBY",
+      "disclaimer": "Notice: Paper or abstract available at https://arxiv.org/abs/2208.00329, which is subject to the license by the author or copyright owner provided with this content. Please go to the source to verify the license and copyright information for your use."
+    },
+    "tldr": {
+      "model": "tldr@v2.0.0",
+      "text": "This work introduces a new crowdsourced English-language, Participant States dataset, PASTA, and introduces three state-based reasoning tasks that test for the ability to infer when a state is entailed by a story, to revise a story conditioned on a counterfactual state, and to explain the most likely state change given a revised story."
+    },
+    "publicationDate": "2022-07-31",
+    "authors": [
+      {
+        "authorId": "72059959",
+        "name": "Sayontan Ghosh"
+      },
+      {
+        "authorId": "144007901",
+        "name": "Mahnaz Koupaee"
+      },
+      {
+        "authorId": "2254303864",
+        "name": "I-Sen Chen"
+      },
+      {
+        "authorId": "2034063",
+        "name": "Francis Ferraro"
+      },
+      {
+        "authorId": "1729918",
+        "name": "Nathanael Chambers"
+      },
+      {
+        "authorId": "35217367",
+        "name": "Niranjan Balasubramanian"
+      }
+    ],
+    "abstract": "Abstract The events in a narrative are understood as a coherent whole via the underlying states of their participants. Often, these participant states are not explicitly mentioned, instead left to be inferred by the reader. A model that understands narratives should likewise infer these implicit states, and even reason about the impact of changes to these states on the narrative. To facilitate this goal, we introduce a new crowdsourced English-language, Participant States dataset, PASTA. This dataset contains inferable participant states; a counterfactual perturbation to each state; and the changes to the story that would be necessary if the counterfactual were true. We introduce three state-based reasoning tasks that test for the ability to infer when a state is entailed by a story, to revise a story conditioned on a counterfactual state, and to explain the most likely state change given a revised story. Experiments show that today\u2019s LLMs can reason about states to some degree, but there is large room for improvement, especially in problems requiring access and ability to reason with diverse types of knowledge (e.g., physical, numerical, factual).1"
+  }
+]

replay_traces/2208.00329/processed_papers/2208.00329/usage_context_labels.json

@@ -0,0 +1,292 @@
+{
+  "paper_id": "2208.00329",
+  "num_contexts": 20,
+  "label_set": [
+    "Background",
+    "Uses",
+    "Extends",
+    "CompareOrContrast",
+    "Motivation",
+    "Future"
+  ],
+  "labels": [
+    {
+      "id": 1,
+      "label": "Uses",
+      "confidence": 0.9254917502403259,
+      "confidence_margin": 0.8626327514648438,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "c1d02fc3786fb5e5b0543703af95046253109d4e",
+      "citing_title": "Inductive Bias Extraction and Matching for LLM Prompts",
+      "text": "The PASTA dataset is an extension of ROCStories that substitutes alternative events into the stories, which may or may not match up with the original summary sentence <CITED HERE>."
+    },
+    {
+      "id": 2,
+      "label": "Uses",
+      "confidence": 0.5409758687019348,
+      "confidence_margin": 0.14535099267959595,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "a6924f6b715327b0f24d044e9e8ef799b3f4a0a2",
+      "citing_title": "Electrifying the Story Climax via Axial Self-Attention in GPT-3 Transformer Block",
+      "text": "The dataset is often separated into four subsets: training, testing, evaluation, and validation [32\u201339]."
+    },
+    {
+      "id": 3,
+      "label": "Background",
+      "confidence": 0.8934071660041809,
+      "confidence_margin": 0.7892690300941467,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "PASTA <CITED HERE> examined implied states and preturbed these states to examine changes in situational narratives."
+    },
+    {
+      "id": 4,
+      "label": "Uses",
+      "confidence": 0.9904201626777649,
+      "confidence_margin": 0.9823774695396423,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "In the following paragraphs, we briefly describe the PASTA <CITED HERE> and SAGA (Vallu-rupalli et al., 2024) datasets and how these datasets\u2019 annotations relate to conditions and outcomes."
+    },
+    {
+      "id": 5,
+      "label": "Background",
+      "confidence": 0.9986065030097961,
+      "confidence_margin": 0.9977977275848389,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "\u2026of reasoning is challenging because: (1) Conditions that to relate to entity properties and states are not always explicitly stated in a narrative but are implicitly understood through forming a coherent mental representation <CITED HERE> and acquiring this implicit knowledge is not easy."
+    },
+    {
+      "id": 6,
+      "label": "Background",
+      "confidence": 0.9968738555908203,
+      "confidence_margin": 0.9947959780693054,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "\u2026of these conditions, like Sam trusting his/her dad or Sam being a small child, are relevant to the goal, with a high likelihood of influencing the outcome, while other conditions that <CITED HERE>; Vallurupalli et al., 2024). might be true are irrelevant to the outcome\u2014like Sam being male."
+    },
+    {
+      "id": 7,
+      "label": "Background",
+      "confidence": 0.9994476437568665,
+      "confidence_margin": 0.9992915987968445,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "( 4) Large Language Models (LLMs) (Brown et al., 2020; Ouyang et al., 2022, inter alia ), while powerful, do not necessarily perform well on tasks requiring counterfactual reasoning (Fang et al., 2025; Lin, 2004; <CITED HERE>; Qin et al., 2019)."
+    },
+    {
+      "id": 8,
+      "label": "Uses",
+      "confidence": 0.9994866847991943,
+      "confidence_margin": 0.9991527199745178,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "We expand the 3 categories used in PASTA <CITED HERE>, for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026"
+    },
+    {
+      "id": 9,
+      "label": "Uses",
+      "confidence": 0.9968955516815186,
+      "confidence_margin": 0.9944096207618713,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "We leverage two previously released datasets PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig."
+    },
+    {
+      "id": 10,
+      "label": "Uses",
+      "confidence": 0.9981223940849304,
+      "confidence_margin": 0.997296929359436,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "text": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026"
+    },
+    {
+      "id": 11,
+      "label": "Uses",
+      "confidence": 0.915876567363739,
+      "confidence_margin": 0.8748534321784973,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "text": "With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in PASTA <CITED HERE>."
+    },
+    {
+      "id": 12,
+      "label": "Background",
+      "confidence": 0.9987213015556335,
+      "confidence_margin": 0.9978130459785461,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "text": "In PASTA <CITED HERE>, original ROCStories (\u201cactual stories\u201d) have up to three \u201calternative\u201d stories."
+    },
+    {
+      "id": 13,
+      "label": "Uses",
+      "confidence": 0.8018349409103394,
+      "confidence_margin": 0.689209520816803,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "text": "\u2026stories shown: in alternative 1 (top right), a different Figure 1: A participant\u2019s goal inferred from the actual story when applied to 3 alternative stories, drawn from the PASTA dataset <CITED HERE>; slightly varying actions in the stories lead to different goal achievement outcomes."
+    },
+    {
+      "id": 14,
+      "label": "Background",
+      "confidence": 0.9973942041397095,
+      "confidence_margin": 0.996073305606842,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "text": "PASTA <CITED HERE> introduced implied states that stories depend upon and examined the tasks of state inference from alternative stories and story rewriting for alternative states."
+    },
+    {
+      "id": 15,
+      "label": "Background",
+      "confidence": 0.9965572357177734,
+      "confidence_margin": 0.9946063160896301,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "text": "Third, while pre-trained large language models (LLMs) are powerful (Brown et al., 2020; Wei et al., 2022, inter alia ), they may perform poorly on tasks requiring robust reasoning <CITED HERE>; Zellers et al., 2019; Qin et al., 2019)."
+    },
+    {
+      "id": 16,
+      "label": "Uses",
+      "confidence": 0.9981212019920349,
+      "confidence_margin": 0.996633768081665,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "text": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset <CITED HERE>."
+    },
+    {
+      "id": 17,
+      "label": "Background",
+      "confidence": 0.9918141961097717,
+      "confidence_margin": 0.9873102307319641,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "d723193c0453223803ffb926354cd6d2dee32b06",
+      "citing_title": "EvEval: A Comprehensive Evaluation of Event Semantics for Large Language Models",
+      "text": "Learning other relations such as event temporality needs more context information and knowledge since it is more subjected to specific situations <CITED HERE>."
+    },
+    {
+      "id": 18,
+      "label": "Background",
+      "confidence": 0.9065139293670654,
+      "confidence_margin": 0.8178352117538452,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "293583961efdf22c0905cc04465aa88ea96826ec",
+      "citing_title": "Causal schema induction for knowledge discovery",
+      "text": ", 2021), of participant states <CITED HERE>; Vallurupalli et al., 2022), and of disease where organisms are conceived of as causative agents, e."
+    },
+    {
+      "id": 19,
+      "label": "Background",
+      "confidence": 0.9994509816169739,
+      "confidence_margin": 0.9992090463638306,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "293583961efdf22c0905cc04465aa88ea96826ec",
+      "citing_title": "Causal schema induction for knowledge discovery",
+      "text": "Participant-centeredness is featured in studies of narrative (Propp, 1968; Caselli and Vossen, 2016; Brahman et al., 2021), of participant states <CITED HERE>; Vallurupalli et al., 2022), and of disease where organisms are conceived of as causative agents, e.g., the pathogen tubercle\u2026"
+    },
+    {
+      "id": 20,
+      "label": "Background",
+      "confidence": 0.9978366494178772,
+      "confidence_margin": 0.9965800642967224,
+      "cue_span": "",
+      "rationale": "scibert_model",
+      "citing_paper_id": "2b914691a44ab1c8bcb0104b8079d86908d98729",
+      "citing_title": "Who Plays Which Role? Protagonist Detection and Classification in Moral Discourse",
+      "text": "Beyond moral discourse, modeling actors and their roles has a long tradition in discourse analysis, for instance, through semantic role labeling (Ruppenhofer et al., 2009; Roth and Lap-ata, 2015; Bornheim et al., 2024) and participant modeling (Tilk et al., 2016; <CITED HERE>."
+    }
+  ],
+  "citing_paper_labels": [
+    {
+      "citing_paper_id": "c1d02fc3786fb5e5b0543703af95046253109d4e",
+      "citing_title": "Inductive Bias Extraction and Matching for LLM Prompts",
+      "label": "Uses",
+      "evidence_context_ids": [
+        1
+      ]
+    },
+    {
+      "citing_paper_id": "a6924f6b715327b0f24d044e9e8ef799b3f4a0a2",
+      "citing_title": "Electrifying the Story Climax via Axial Self-Attention in GPT-3 Transformer Block",
+      "label": "Uses",
+      "evidence_context_ids": [
+        2
+      ]
+    },
+    {
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "label": "Uses",
+      "evidence_context_ids": [
+        4,
+        8,
+        9,
+        10
+      ]
+    },
+    {
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "label": "Uses",
+      "evidence_context_ids": [
+        11,
+        13,
+        16
+      ]
+    },
+    {
+      "citing_paper_id": "d723193c0453223803ffb926354cd6d2dee32b06",
+      "citing_title": "EvEval: A Comprehensive Evaluation of Event Semantics for Large Language Models",
+      "label": "Background",
+      "evidence_context_ids": []
+    },
+    {
+      "citing_paper_id": "293583961efdf22c0905cc04465aa88ea96826ec",
+      "citing_title": "Causal schema induction for knowledge discovery",
+      "label": "Background",
+      "evidence_context_ids": []
+    },
+    {
+      "citing_paper_id": "2b914691a44ab1c8bcb0104b8079d86908d98729",
+      "citing_title": "Who Plays Which Role? Protagonist Detection and Classification in Moral Discourse",
+      "label": "Background",
+      "evidence_context_ids": []
+    }
+  ],
+  "final_label": "Uses"
+}

replay_traces/2208.00329/processed_papers/2208.00329/usage_contexts.json

@@ -0,0 +1,326 @@
+{
+  "paper_id": "2208.00329",
+  "total_citations": 7,
+  "num_contexts": 20,
+  "num_citing_with_context": 7,
+  "num_citing_without_context": 0,
+  "num_influential_citations": 2,
+  "num_influential_with_context": 2,
+  "influential_contexts": [
+    {
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "external_ids": {
+        "DBLP": "journals/corr/abs-2506-01253",
+        "ArXiv": "2506.01253",
+        "DOI": "10.48550/arXiv.2506.01253",
+        "CorpusId": 279074979
+      },
+      "contexts": [
+        {
+          "text": "PASTA <CITED HERE> examined implied states and preturbed these states to examine changes in situational narratives.",
+          "text_raw": "PASTA (Ghosh et al., 2023) examined implied states and preturbed these states to examine changes in situational narratives.",
+          "intents": []
+        },
+        {
+          "text": "In the following paragraphs, we briefly describe the PASTA <CITED HERE> and SAGA (Vallu-rupalli et al., 2024) datasets and how these datasets\u2019 annotations relate to conditions and outcomes.",
+          "text_raw": "In the following paragraphs, we briefly describe the PASTA (Ghosh et al., 2023) and SAGA (Vallu-rupalli et al., 2024) datasets and how these datasets\u2019 annotations relate to conditions and outcomes.",
+          "intents": []
+        },
+        {
+          "text": "\u2026of reasoning is challenging because: (1) Conditions that to relate to entity properties and states are not always explicitly stated in a narrative but are implicitly understood through forming a coherent mental representation <CITED HERE> and acquiring this implicit knowledge is not easy.",
+          "text_raw": "\u2026of reasoning is challenging because: (1) Conditions that to relate to entity properties and states are not always explicitly stated in a narrative but are implicitly understood through forming a coherent mental representation (Ghosh et al., 2023) and acquiring this implicit knowledge is not easy.",
+          "intents": []
+        },
+        {
+          "text": "\u2026of these conditions, like Sam trusting his/her dad or Sam being a small child, are relevant to the goal, with a high likelihood of influencing the outcome, while other conditions that <CITED HERE>; Vallurupalli et al., 2024). might be true are irrelevant to the outcome\u2014like Sam being male.",
+          "text_raw": "\u2026of these conditions, like Sam trusting his/her dad or Sam being a small child, are relevant to the goal, with a high likelihood of influencing the outcome, while other conditions that (Ghosh et al., 2023; Vallurupalli et al., 2024). might be true are irrelevant to the outcome\u2014like Sam being male.",
+          "intents": []
+        },
+        {
+          "text": "( 4) Large Language Models (LLMs) (Brown et al., 2020; Ouyang et al., 2022, inter alia ), while powerful, do not necessarily perform well on tasks requiring counterfactual reasoning (Fang et al., 2025; Lin, 2004; <CITED HERE>; Qin et al., 2019).",
+          "text_raw": "( 4) Large Language Models (LLMs) (Brown et al., 2020; Ouyang et al., 2022, inter alia ), while powerful, do not necessarily perform well on tasks requiring counterfactual reasoning (Fang et al., 2025; Lin, 2004; Ghosh et al., 2023; Qin et al., 2019).",
+          "intents": []
+        },
+        {
+          "text": "We expand the 3 categories used in PASTA <CITED HERE>, for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+          "text_raw": "We expand the 3 categories used in PASTA (Ghosh et al., 2023), for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+          "intents": []
+        },
+        {
+          "text": "We leverage two previously released datasets PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+          "text_raw": "We leverage two previously released datasets PASTA (Ghosh et al., 2023) and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+          "intents": []
+        },
+        {
+          "text": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026",
+          "text_raw": "We leverage PASTA (Ghosh et al., 2023) and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026",
+          "intents": []
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "external_ids": {
+        "DBLP": "journals/corr/abs-2408-05793",
+        "ArXiv": "2408.05793",
+        "DOI": "10.48550/arXiv.2408.05793",
+        "CorpusId": 271855571
+      },
+      "contexts": [
+        {
+          "text": "With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in PASTA <CITED HERE>.",
+          "text_raw": "With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in PASTA (Ghosh et al., 2023).",
+          "intents": [
+            "methodology"
+          ]
+        },
+        {
+          "text": "In PASTA <CITED HERE>, original ROCStories (\u201cactual stories\u201d) have up to three \u201calternative\u201d stories.",
+          "text_raw": "In PASTA (Ghosh et al., 2023), original ROCStories (\u201cactual stories\u201d) have up to three \u201calternative\u201d stories.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "\u2026stories shown: in alternative 1 (top right), a different Figure 1: A participant\u2019s goal inferred from the actual story when applied to 3 alternative stories, drawn from the PASTA dataset <CITED HERE>; slightly varying actions in the stories lead to different goal achievement outcomes.",
+          "text_raw": "\u2026stories shown: in alternative 1 (top right), a different Figure 1: A participant\u2019s goal inferred from the actual story when applied to 3 alternative stories, drawn from the PASTA dataset (Ghosh et al., 2023); slightly varying actions in the stories lead to different goal achievement outcomes.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "PASTA <CITED HERE> introduced implied states that stories depend upon and examined the tasks of state inference from alternative stories and story rewriting for alternative states.",
+          "text_raw": "PASTA (Ghosh et al., 2023) introduced implied states that stories depend upon and examined the tasks of state inference from alternative stories and story rewriting for alternative states.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "Third, while pre-trained large language models (LLMs) are powerful (Brown et al., 2020; Wei et al., 2022, inter alia ), they may perform poorly on tasks requiring robust reasoning <CITED HERE>; Zellers et al., 2019; Qin et al., 2019).",
+          "text_raw": "Third, while pre-trained large language models (LLMs) are powerful (Brown et al., 2020; Wei et al., 2022, inter alia ), they may perform poorly on tasks requiring robust reasoning (Ghosh et al., 2023; Zellers et al., 2019; Qin et al., 2019).",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset <CITED HERE>.",
+          "text_raw": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset (Ghosh et al., 2023).",
+          "intents": [
+            "methodology"
+          ]
+        }
+      ]
+    }
+  ],
+  "citing_papers": [
+    {
+      "citing_paper_id": "c1d02fc3786fb5e5b0543703af95046253109d4e",
+      "title": "Inductive Bias Extraction and Matching for LLM Prompts",
+      "external_ids": {
+        "ArXiv": "2508.10295",
+        "DBLP": "journals/corr/abs-2508-10295",
+        "DOI": "10.48550/arXiv.2508.10295",
+        "CorpusId": 280649627
+      },
+      "is_influential": false,
+      "contexts": [
+        {
+          "text": "The PASTA dataset is an extension of ROCStories that substitutes alternative events into the stories, which may or may not match up with the original summary sentence <CITED HERE>.",
+          "text_raw": "The PASTA dataset is an extension of ROCStories that substitutes alternative events into the stories, which may or may not match up with the original summary sentence (Ghosh et al., 2023).",
+          "intents": []
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "a6924f6b715327b0f24d044e9e8ef799b3f4a0a2",
+      "title": "Electrifying the Story Climax via Axial Self-Attention in GPT-3 Transformer Block",
+      "external_ids": {
+        "DBLP": "journals/sncs/VD25",
+        "DOI": "10.1007/s42979-025-04091-1",
+        "CorpusId": 279483975
+      },
+      "is_influential": false,
+      "contexts": [
+        {
+          "text": "The dataset is often separated into four subsets: training, testing, evaluation, and validation [32\u201339].",
+          "text_raw": "The dataset is often separated into four subsets: training, testing, evaluation, and validation [32\u201339].",
+          "intents": []
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "external_ids": {
+        "DBLP": "journals/corr/abs-2506-01253",
+        "ArXiv": "2506.01253",
+        "DOI": "10.48550/arXiv.2506.01253",
+        "CorpusId": 279074979
+      },
+      "is_influential": true,
+      "contexts": [
+        {
+          "text": "PASTA <CITED HERE> examined implied states and preturbed these states to examine changes in situational narratives.",
+          "text_raw": "PASTA (Ghosh et al., 2023) examined implied states and preturbed these states to examine changes in situational narratives.",
+          "intents": []
+        },
+        {
+          "text": "In the following paragraphs, we briefly describe the PASTA <CITED HERE> and SAGA (Vallu-rupalli et al., 2024) datasets and how these datasets\u2019 annotations relate to conditions and outcomes.",
+          "text_raw": "In the following paragraphs, we briefly describe the PASTA (Ghosh et al., 2023) and SAGA (Vallu-rupalli et al., 2024) datasets and how these datasets\u2019 annotations relate to conditions and outcomes.",
+          "intents": []
+        },
+        {
+          "text": "\u2026of reasoning is challenging because: (1) Conditions that to relate to entity properties and states are not always explicitly stated in a narrative but are implicitly understood through forming a coherent mental representation <CITED HERE> and acquiring this implicit knowledge is not easy.",
+          "text_raw": "\u2026of reasoning is challenging because: (1) Conditions that to relate to entity properties and states are not always explicitly stated in a narrative but are implicitly understood through forming a coherent mental representation (Ghosh et al., 2023) and acquiring this implicit knowledge is not easy.",
+          "intents": []
+        },
+        {
+          "text": "\u2026of these conditions, like Sam trusting his/her dad or Sam being a small child, are relevant to the goal, with a high likelihood of influencing the outcome, while other conditions that <CITED HERE>; Vallurupalli et al., 2024). might be true are irrelevant to the outcome\u2014like Sam being male.",
+          "text_raw": "\u2026of these conditions, like Sam trusting his/her dad or Sam being a small child, are relevant to the goal, with a high likelihood of influencing the outcome, while other conditions that (Ghosh et al., 2023; Vallurupalli et al., 2024). might be true are irrelevant to the outcome\u2014like Sam being male.",
+          "intents": []
+        },
+        {
+          "text": "( 4) Large Language Models (LLMs) (Brown et al., 2020; Ouyang et al., 2022, inter alia ), while powerful, do not necessarily perform well on tasks requiring counterfactual reasoning (Fang et al., 2025; Lin, 2004; <CITED HERE>; Qin et al., 2019).",
+          "text_raw": "( 4) Large Language Models (LLMs) (Brown et al., 2020; Ouyang et al., 2022, inter alia ), while powerful, do not necessarily perform well on tasks requiring counterfactual reasoning (Fang et al., 2025; Lin, 2004; Ghosh et al., 2023; Qin et al., 2019).",
+          "intents": []
+        },
+        {
+          "text": "We expand the 3 categories used in PASTA <CITED HERE>, for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+          "text_raw": "We expand the 3 categories used in PASTA (Ghosh et al., 2023), for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+          "intents": []
+        },
+        {
+          "text": "We leverage two previously released datasets PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+          "text_raw": "We leverage two previously released datasets PASTA (Ghosh et al., 2023) and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+          "intents": []
+        },
+        {
+          "text": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026",
+          "text_raw": "We leverage PASTA (Ghosh et al., 2023) and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026",
+          "intents": []
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "external_ids": {
+        "DBLP": "journals/corr/abs-2408-05793",
+        "ArXiv": "2408.05793",
+        "DOI": "10.48550/arXiv.2408.05793",
+        "CorpusId": 271855571
+      },
+      "is_influential": true,
+      "contexts": [
+        {
+          "text": "With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in PASTA <CITED HERE>.",
+          "text_raw": "With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in PASTA (Ghosh et al., 2023).",
+          "intents": [
+            "methodology"
+          ]
+        },
+        {
+          "text": "In PASTA <CITED HERE>, original ROCStories (\u201cactual stories\u201d) have up to three \u201calternative\u201d stories.",
+          "text_raw": "In PASTA (Ghosh et al., 2023), original ROCStories (\u201cactual stories\u201d) have up to three \u201calternative\u201d stories.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "\u2026stories shown: in alternative 1 (top right), a different Figure 1: A participant\u2019s goal inferred from the actual story when applied to 3 alternative stories, drawn from the PASTA dataset <CITED HERE>; slightly varying actions in the stories lead to different goal achievement outcomes.",
+          "text_raw": "\u2026stories shown: in alternative 1 (top right), a different Figure 1: A participant\u2019s goal inferred from the actual story when applied to 3 alternative stories, drawn from the PASTA dataset (Ghosh et al., 2023); slightly varying actions in the stories lead to different goal achievement outcomes.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "PASTA <CITED HERE> introduced implied states that stories depend upon and examined the tasks of state inference from alternative stories and story rewriting for alternative states.",
+          "text_raw": "PASTA (Ghosh et al., 2023) introduced implied states that stories depend upon and examined the tasks of state inference from alternative stories and story rewriting for alternative states.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "Third, while pre-trained large language models (LLMs) are powerful (Brown et al., 2020; Wei et al., 2022, inter alia ), they may perform poorly on tasks requiring robust reasoning <CITED HERE>; Zellers et al., 2019; Qin et al., 2019).",
+          "text_raw": "Third, while pre-trained large language models (LLMs) are powerful (Brown et al., 2020; Wei et al., 2022, inter alia ), they may perform poorly on tasks requiring robust reasoning (Ghosh et al., 2023; Zellers et al., 2019; Qin et al., 2019).",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset <CITED HERE>.",
+          "text_raw": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset (Ghosh et al., 2023).",
+          "intents": [
+            "methodology"
+          ]
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "d723193c0453223803ffb926354cd6d2dee32b06",
+      "title": "EvEval: A Comprehensive Evaluation of Event Semantics for Large Language Models",
+      "external_ids": {
+        "ArXiv": "2305.15268",
+        "DBLP": "journals/corr/abs-2305-15268",
+        "DOI": "10.48550/arXiv.2305.15268",
+        "CorpusId": 258866165
+      },
+      "is_influential": false,
+      "contexts": [
+        {
+          "text": "Learning other relations such as event temporality needs more context information and knowledge since it is more subjected to specific situations <CITED HERE>.",
+          "text_raw": "Learning other relations such as event temporality needs more context information and knowledge since it is more subjected to specific situations (Ghosh et al., 2022).",
+          "intents": [
+            "background"
+          ]
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "293583961efdf22c0905cc04465aa88ea96826ec",
+      "title": "Causal schema induction for knowledge discovery",
+      "external_ids": {
+        "ArXiv": "2303.15381",
+        "DBLP": "journals/corr/abs-2303-15381",
+        "DOI": "10.48550/arXiv.2303.15381",
+        "CorpusId": 257766554
+      },
+      "is_influential": false,
+      "contexts": [
+        {
+          "text": ", 2021), of participant states <CITED HERE>; Vallurupalli et al., 2022), and of disease where organisms are conceived of as causative agents, e.",
+          "text_raw": ", 2021), of participant states (Ghosh et al., 2022; Vallurupalli et al., 2022), and of disease where organisms are conceived of as causative agents, e.",
+          "intents": [
+            "background"
+          ]
+        },
+        {
+          "text": "Participant-centeredness is featured in studies of narrative (Propp, 1968; Caselli and Vossen, 2016; Brahman et al., 2021), of participant states <CITED HERE>; Vallurupalli et al., 2022), and of disease where organisms are conceived of as causative agents, e.g., the pathogen tubercle\u2026",
+          "text_raw": "Participant-centeredness is featured in studies of narrative (Propp, 1968; Caselli and Vossen, 2016; Brahman et al., 2021), of participant states (Ghosh et al., 2022; Vallurupalli et al., 2022), and of disease where organisms are conceived of as causative agents, e.g., the pathogen tubercle\u2026",
+          "intents": [
+            "background"
+          ]
+        }
+      ]
+    },
+    {
+      "citing_paper_id": "2b914691a44ab1c8bcb0104b8079d86908d98729",
+      "title": "Who Plays Which Role? Protagonist Detection and Classification in Moral Discourse",
+      "external_ids": {
+        "DBLP": "conf/eacl/SommerB26",
+        "DOI": "10.18653/v1/2026.eacl-srw.27",
+        "CorpusId": 286822758
+      },
+      "is_influential": false,
+      "contexts": [
+        {
+          "text": "Beyond moral discourse, modeling actors and their roles has a long tradition in discourse analysis, for instance, through semantic role labeling (Ruppenhofer et al., 2009; Roth and Lap-ata, 2015; Bornheim et al., 2024) and participant modeling (Tilk et al., 2016; <CITED HERE>.",
+          "text_raw": "Beyond moral discourse, modeling actors and their roles has a long tradition in discourse analysis, for instance, through semantic role labeling (Ruppenhofer et al., 2009; Roth and Lap-ata, 2015; Bornheim et al., 2024) and participant modeling (Tilk et al., 2016; Ghosh et al., 2023).",
+          "intents": []
+        }
+      ]
+    }
+  ]
+}

replay_traces/2208.00329/processed_papers/2208.00329/usage_contributions.json

@@ -0,0 +1,43 @@
+{
+  "paper_id": "2208.00329",
+  "final_label": "EXTENDS",
+  "contributions": [
+    {
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "label": "USES",
+      "paper_claim": "The citing paper adopts the methodology used for obtaining counterfactuals in the target paper to generate minimally updated goal annotations.",
+      "claim": "The citing paper adopts the methodology used for obtaining counterfactuals in the target paper to generate minimally updated goal annotations.",
+      "cluster_title": "Uses target methodology for dataset creation",
+      "cluster_key": "USES|methodology|dataset_creation",
+      "evidence_span": "reflecting the process used for obtaining the counterfactual in ~PASTA~<CITED HERE>",
+      "rationale": "The citing paper explicitly states that their dataset annotation process uses or mirrors the method used to obtain counterfactuals in the target paper.",
+      "contexts": [
+        "Target-citing paragraph: We use a third HIT when one or more annotators identify that a participant's goal is inferrable from $S^{c_k}$.  With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in ~PASTA~<CITED HERE>. See \\cref{tab:HITS-annotation} for the  annotations and the HITs used for obtaining them.",
+        "Target-citing paragraph: \\subsubsection{Worker Selection and Qualifications}\n\\label{app:HIT_information:qualifications}\nFor our initial alpha runs of the HITs we used all workers who meet our community standard quality criteria, such as requiring a 98\\% or greater HIT acceptance rate and the completion of 1000 approved HITs. In addition, we required the worker's stated location to be in the USA, UK, Canada, Australia, or New Zealand. We used the location requirement to avoid language-based artifacts given the language-dependent semantic phenomena and the high subjectivity our work can elicit.    \nWe did not use requester-generated qualification tests, though in early iterations we found that annotators who had completed at least 50 HITs in our prior work~<CITED HERE> provided the most reliable annotations; the vast majority of our responses are from this group."
+      ],
+      "source": "arxiv_paragraphs"
+    },
+    {
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "label": "USES",
+      "paper_claim": "The authors leverage the PASTA dataset and its annotations to generate and validate story outcomes.",
+      "claim": "The authors leverage the PASTA dataset and its annotations to generate and validate story outcomes.",
+      "cluster_title": "Uses target dataset for data generation",
+      "cluster_key": "USES|dataset|data_generation",
+      "evidence_span": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions.",
+      "rationale": "The citing paper explicitly uses the PASTA dataset and its annotated conditions to generate outcomes for SAGA and News Stories, as well as to validate them.",
+      "contexts": [
+        "Target sentence: We expand the 3 categories used in PASTA <CITED HERE>, for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+        "Target sentence: We leverage two previously released datasets PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+        "Target sentence: We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026"
+      ],
+      "source": "usage_contexts_fallback"
+    }
+  ],
+  "source": "arxiv_paragraphs",
+  "fallback_citing_ids": [
+    "ab73ca481256767addce56b20eb48ac183169e01"
+  ]
+}

replay_traces/2208.00329/processed_papers/2208.00329/usage_discovery_from_contributions.json

@@ -0,0 +1,38 @@
+{
+  "paper_id": "2208.00329",
+  "decision": "",
+  "justification": "",
+  "clusters": [
+    {
+      "cluster_id": "C1",
+      "count": "1",
+      "representative_claim": "Uses target methodology for dataset creation",
+      "cluster_key": "USES|methodology|dataset_creation",
+      "cluster_title": "Uses target methodology for dataset creation",
+      "claim_indices": [
+        "0"
+      ],
+      "source_cluster_ids": [
+        "C1"
+      ],
+      "merge_rationale": "The citing paper adopts the methodology used in the target paper to generate its own dataset."
+    },
+    {
+      "cluster_id": "C2",
+      "count": "1",
+      "representative_claim": "Uses target dataset for data generation",
+      "cluster_key": "USES|dataset|data_generation",
+      "cluster_title": "Uses target dataset for data generation",
+      "claim_indices": [
+        "1"
+      ],
+      "source_cluster_ids": [
+        "C2"
+      ],
+      "merge_rationale": "The citing paper uses the PASTA dataset and its annotations directly to generate and validate story outcomes."
+    }
+  ],
+  "dropped_clusters": [],
+  "cluster_refine_method": "llm_centroid_merge_filter",
+  "cluster_refine_source": "usage_contributions.json"
+}

replay_traces/2208.00329/processed_papers/2208.00329/usage_uses_extends_verified.json

@@ -0,0 +1,150 @@
+{
+  "paper_id": "2208.00329",
+  "target": {
+    "title": "PASTA: A Dataset for Modeling PArticipant STAtes in Narratives",
+    "first_author_last": "Ghosh",
+    "year": "2022"
+  },
+  "candidates_total": 9,
+  "candidates_considered": 9,
+  "verification_batch_size": 25,
+  "verification_num_batches": 1,
+  "candidates_selected": 4,
+  "verified": [
+    {
+      "id": 8,
+      "label": "EXTENDS",
+      "cue_span": "We expand the 3 categories used in PASTA",
+      "rationale": "The citing paper explicitly expands upon the categorical framework introduced in the target paper.",
+      "text": "We expand the 3 categories used in PASTA <CITED HERE>, for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 10,
+      "label": "USES",
+      "cue_span": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes",
+      "rationale": "The authors explicitly state they are leveraging the target dataset to generate and validate outcomes.",
+      "text": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 16,
+      "label": "USES",
+      "cue_span": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset",
+      "rationale": "The authors used stories specifically from the PASTA dataset for their own annotation process.",
+      "text": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset <CITED HERE>.",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 9,
+      "label": "USES",
+      "cue_span": "We leverage two previously released datasets PASTA",
+      "rationale": "The authors explicitly mention leveraging the PASTA dataset as part of their work.",
+      "text": "We leverage two previously released datasets PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 4,
+      "label": "NOT_CONFIRMED",
+      "cue_span": "",
+      "rationale": "The sentence only indicates an intention to describe the datasets, not a specific use or extension of them.",
+      "text": "In the following paragraphs, we briefly describe the PASTA <CITED HERE> and SAGA (Vallu-rupalli et al., 2024) datasets and how these datasets\u2019 annotations relate to conditions and outcomes.",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 1,
+      "label": "NOT_CONFIRMED",
+      "cue_span": "",
+      "rationale": "The sentence provides a description of what the target paper introduces without stating that the citing paper uses it.",
+      "text": "The PASTA dataset is an extension of ROCStories that substitutes alternative events into the stories, which may or may not match up with the original summary sentence <CITED HERE>.",
+      "citing_paper_id": "c1d02fc3786fb5e5b0543703af95046253109d4e",
+      "citing_title": "Inductive Bias Extraction and Matching for LLM Prompts",
+      "original_label": "Uses"
+    },
+    {
+      "id": 11,
+      "label": "NOT_CONFIRMED",
+      "cue_span": "",
+      "rationale": "The sentence mentions that the resulting annotations reflect a process from the target paper but lacks an explicit adoption cue.",
+      "text": "With this HIT we obtain a new set of goal annotations reusing and modifying the free-form text annotations from the actual story to obtain annotations that are also minimally updated reflecting the process used for obtaining the counterfactual in PASTA <CITED HERE>.",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 13,
+      "label": "NOT_CONFIRMED",
+      "cue_span": "",
+      "rationale": "The sentence lacks an explicit citing-paper actor phrase such as 'we' or 'our' as required by the instructions.",
+      "text": "\u2026stories shown: in alternative 1 (top right), a different Figure 1: A participant\u2019s goal inferred from the actual story when applied to 3 alternative stories, drawn from the PASTA dataset <CITED HERE>; slightly varying actions in the stories lead to different goal achievement outcomes.",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 2,
+      "label": "NOT_CONFIRMED",
+      "cue_span": "",
+      "rationale": "The sentence is a general description of dataset subsets and lacks an explicit adoption cue by the citing authors.",
+      "text": "The dataset is often separated into four subsets: training, testing, evaluation, and validation [32\u201339].",
+      "citing_paper_id": "a6924f6b715327b0f24d044e9e8ef799b3f4a0a2",
+      "citing_title": "Electrifying the Story Climax via Axial Self-Attention in GPT-3 Transformer Block",
+      "original_label": "Uses"
+    }
+  ],
+  "confirmed": [
+    {
+      "id": 8,
+      "label": "EXTENDS",
+      "cue_span": "We expand the 3 categories used in PASTA",
+      "rationale": "The citing paper explicitly expands upon the categorical framework introduced in the target paper.",
+      "text": "We expand the 3 categories used in PASTA <CITED HERE>, for error analysis on 200 random states on the story state inference task, to 4 categories and group all conditions into these as follows: (a) Physical: This category includes natural physical attributes of an entity such as size, age,\u2026",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 10,
+      "label": "USES",
+      "cue_span": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes",
+      "rationale": "The authors explicitly state they are leveraging the target dataset to generate and validate outcomes.",
+      "text": "We leverage PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) datasets to generate outcomes of SAGA and News Stories and validate these using both our generated and PASTA\u2019s crowd-annotated conditions. outcome is implicitly understood through constructing counterfactual mental\u2026",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 16,
+      "label": "USES",
+      "cue_span": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset",
+      "rationale": "The authors used stories specifically from the PASTA dataset for their own annotation process.",
+      "text": "We annotated ROC stories (Mostafazadeh et al., 2016) that have corresponding alternative stories in the PASTA dataset <CITED HERE>.",
+      "citing_paper_id": "494f3c55553161be831f725a7b55c6095470c5cb",
+      "citing_title": "SAGA: A Participant-specific Examination of Story Alternatives and Goal Applicability for a Deeper Understanding of Complex Events",
+      "original_label": "Uses"
+    },
+    {
+      "id": 9,
+      "label": "USES",
+      "cue_span": "We leverage two previously released datasets PASTA",
+      "rationale": "The authors explicitly mention leveraging the PASTA dataset as part of their work.",
+      "text": "We leverage two previously released datasets PASTA <CITED HERE> and SAGA (Vallurupalli et al., 2024) consisting of participants\u2019 goal and state annotations (shown in Fig.",
+      "citing_paper_id": "ab73ca481256767addce56b20eb48ac183169e01",
+      "citing_title": "CoRE: Condition-based Reasoning for Identifying Outcome Variance in Complex Events",
+      "original_label": "Uses"
+    }
+  ],
+  "confirmed_extends": 1,
+  "confirmed_uses": 3,
+  "final_label": "EXTENDS"
+}