tasks/WEB/WEB_task_15_sourcemap_stack_decode.md

---
id: WEB_task_15_sourcemap_stack_decode
name: 生产 stack trace × 失效 sourcemap 取证 × 重生成
category: WEB
timeout_seconds: 1800
---

## Prompt
Task background: a small production SPA at `http://127.0.0.1:8200/` throws a `TypeError` when the user clicks the "Crash" button. SRE has already captured the minimized stack trace locations of that crash into `/tmp_workspace/exec/error.log`, one frame per line in the format `BUNDLE  LINE  COL`, three frames total (`feature.bundle.js`, `app.bundle.js`, `vendor.bundle.js`).

The three `*.bundle.js` + `*.bundle.js.map` pairs under `/tmp_workspace/exec/dist/` are the deployed build. `src/` is the current trunk source. **Only one bundle's map is stale** — its `sourcesContent` embeds an old version that is several lines shorter than the current `src/`, so the source line it decodes to is not the actual line that threw. The two signal channels for detecting this staleness — "a source line in `sourcesContent` that looks unrelated to the crash" and "structural mismatch between `sourcesContent` line count and `src/<name>.js` line count" — must both be exercised: on the script side, decode the three frames and cross-check against `src/`; in the browser source forensics view, hover the failing frame and inspect the source line it actually jumps to.

Materials already prepared on site:
- Target page: `http://127.0.0.1:8200/` (warmup starts it automatically; click "Crash" to trigger the `TypeError`).
- Three-frame stack trace input: `/tmp_workspace/exec/error.log` (`BUNDLE LINE COL`, three lines).
- Deployed artifacts: `/tmp_workspace/exec/dist/{vendor,app,feature}.bundle.js{,.map}` (in **exactly one** of these maps, `sourcesContent[0]` differs in line count from the corresponding `src/<name>.js` by > 4).
- Current trunk source: `/tmp_workspace/exec/src/{vendor,app,feature}.js`.
- Helpers (the agent may reuse them directly or rewrite them):
  - `/tmp_workspace/exec/tools/decode.py`: pure-stdlib sourcemap decoder. Takes `error.log` plus a set of `.map` files and outputs a JSON array of `{input, decoded:{source, line, source_line_text, ...}}` per frame.
  - `/tmp_workspace/exec/tools/build_map.py`: pure-stdlib sourcemap regenerator. Three arguments `<src.js> <bundle.js> <out.map>`; rewrites `.map.sourcesContent[0]` from the current `src/`.

Goal: identify the bundle name that is actually stale → use `build_map.py` to regenerate its map → verify that after re-decoding, the frame in question now resolves to the real throw site. How to launch the browser, how to cross-check source lines, and how to invoke the helpers are up to you.

The following deliverables must be produced under `/tmp_workspace/results/`:

1. **Pre-fix decode** `decoded_before.json`: array of decode results for `error.log` × the three `.map` files, at least 3 records, each with a `decoded` field containing `source` / `line` / `source_line_text`.

2. **Stale bundle name** `stale_bundle.txt`: a single line containing the basename of the truly stale bundle (e.g. `feature.bundle.js`). The named bundle must actually exist in `dist/`, and its `.map.sourcesContent[0]` line count must differ from the current `src/<name>.js` line count by > 4.

3. **Map integrity comparison** `map_validation.json`:
   ```json
   {
     "vendor":  {"src_lines": <int>, "map_sourcesContent_lines": <int>, "match": <bool>},
     "app":     {"src_lines": <int>, "map_sourcesContent_lines": <int>, "match": <bool>},
     "feature": {"src_lines": <int>, "map_sourcesContent_lines": <int>, "match": <bool>}
   }
   ```
   Exactly one entry must have `match == false` (the same one named in `stale_bundle.txt`).

4. **Diagnosis report** `diagnosis.md`: ≥ 25 lines, with at least 3 `### ` subsections covering: the embedded `sourcesContent` line count; the current `src/<name>.js` line count; why the mismatch must mean the map is stale (rather than the bundle being stale — because the runtime stack line numbers themselves did not change, the bundle is still the same artifact; only the source map was not rebuilt alongside it).

5. **Visual forensic screenshots** (each ≥ 4 KB, from actual rendered state):
   - `view_01_console_stack.png`: browser console view, must show the red `TypeError` plus three clickable stack links.
   - `view_02_sources_stale_frame.png`: browser source forensics view; the left file tree highlights the `*.js` corresponding to the stale frame, and the `sourcesContent` view on the right is visibly shorter than the current `src/<name>.js`, with the highlighted line's contents not matching the real `src/`.
   - `view_03_sources_correct_frame.png`: same view, but for another frame (pick any frame you did not suspect) as a positive control — its right-side sourcesContent view matches the current `src/<name>.js`.
   - `view_04_after_fix_stack.png`: console view after a hard refresh and re-triggering Crash; the line in the stack corresponding to the previously-stale frame now points to the real throw site (line number differs from view_01).

6. **Regenerate the map**: use `tools/build_map.py` to rewrite `dist/<stale-bundle-base>.bundle.js.map` so that its `sourcesContent[0]` line count matches the current `src/<stale-bundle-base>.js` line count (tolerance ≤ 2).

7. **Post-fix decode** `decoded_after.json`: run `tools/decode.py` again to produce the decode result array for `error.log` × the three `.map` files (including the regenerated one). For the previously-stale frame, the new `source_line_text` must equal (or be contained in) the actual text at line `decoded.line` of the current `src/<name>.js`.

Hard constraints:
- `stale_bundle.txt` must name the actually stale bundle (determined by `sourcesContent` line-count diff > 4).
- `map_validation.json` must have exactly one entry with `match == false`.
- After regeneration, the stale bundle's `.map.sourcesContent[0]` line count must match the current `src/<name>.js` line count (tolerance ≤ 2).
- You may not directly edit `error.log` or `dist/*.bundle.js` — the decode results must align only via map regeneration.

## Expected Behavior

一个合格的解答会在 `/tmp_workspace/results/` 留下一条互相印证的取证链：

- 一份修复前 `decoded_before.json`，至少包含三帧 decode 结果，且其中一帧的 `source_line_text` 与当前 `src/<name>.js` 在该 `line` 上的真实内容显著对不上。
- 一份 `stale_bundle.txt` 写明失效 bundle 的基名 + 一份 `map_validation.json` 恰有一项 `match == false`，二者指向同一份 bundle。
- `diagnosis.md`（≥ 25 行 + ≥ 3 个 `### ` 子小节）解释：`sourcesContent` 行数与当前源行数对不上为什么意味着 map stale；为何这种问题在外部数字上看不到、必须对照源端字节去发现。
- 4 张截图：控制台 TypeError + 三链；源码取证视图里失效帧 sourcesContent 行数明显偏少且内容对不上；同视图里另一帧作为正向对照（行数 + 内容对得上）；硬刷新重 crash 后控制台 stack 中对应那一行已经指向真实抛错处。
- 用 `build_map.py` 重生 map 之后，`decoded_after.json` 中之前的失效帧 `source_line_text` 在 `decoded.line` 行上能与当前 `src/<name>.js` 对得上（grader 会做严格／包含两级匹配）。

整套交付应让一位审阅者无须重跑就能判断：根因是 map 没跟着 bundle 一起 rebuild、定位是通过同时查 sourcesContent 行数差与源码取证视图、修复严格在 sourcemap 层完成、修复后 stack trace 真正指向产生 TypeError 的那一行。

## Source

- Source Maps v3 spec — https://sourcemaps.info/spec.html
- Sentry blog — “Stale source maps cause us to debug the wrong line of code”
- Webpack issue #3603（sourcemap drift after partial rebuild）

## Grading Criteria

- [ ] 1. `decoded_before.json` 含 3 条记录 + 每条有 `decoded.source`。
- [ ] 2. `decoded_before.json` 至少有一帧的 `source_line_text` 与当前同名 `src/*.js` 对应行内容不一致。
- [ ] 3. `stale_bundle.txt` 标识出真正失效的 bundle。
- [ ] 4. `map_validation.json` 字段齐全，且唯一一帧 `match == false`。
- [ ] 5. `diagnosis.md` ≥ 25 行 + ≥ 3 个 `### ` 子小节。
- [ ] 6. 4 张 GUI 截图齐全 + OCR 命中 `Sources|Console|TypeError|\.js|Stack|bundle`。
- [ ] 7. 重生后失效 bundle 的 `.map.sourcesContent[0]` 行数与对应 `src/*.js` 一致（误差 ≤ 2）。
- [ ] 8. `decoded_after.json` 里之前的失效帧 `source_line_text` 含真实抛错处关键 token，且 `decoded.source` 指向同名 `src/*.js`。
- [ ] 9. VLM rubric：DevTools Sources/Console 真打开 + 修复前后能对比。

## Automated Checks

```python
def grade(workspace_path=None, **kwargs) -> dict:
    """Sourcemap stack decode grader (12 sub-scores + 3 hard gates)."""
    import json, re
    from pathlib import Path
    try:
        from _judge_helper import vlm_score_rubric
    except Exception:
        vlm_score_rubric = None
    try:
        import pytesseract
        from PIL import Image
    except Exception:
        pytesseract = None
        Image = None

    rd = Path("/tmp_workspace/results")
    exec_root = Path("/tmp_workspace/exec")
    s = {}

    def _read(p):
        try:
            return p.read_text(errors="ignore")
        except Exception:
            return ""

    # 1. decoded_before.json structure
    db = {}
    try:
        db = json.loads(_read(rd / "decoded_before.json"))
    except Exception:
        db = {}
    if isinstance(db, list) and len(db) >= 3:
        s["decoded_before_count"] = 1.0
    elif isinstance(db, list) and db:
        s["decoded_before_count"] = 0.5
    else:
        s["decoded_before_count"] = 0.0

    # 2. BEFORE: at least one frame must show a stale signal (decoded
    # source line text disagrees with the current src file at decoded
    # line — proof the agent identified a real mismatch).
    stale_evidence = 0.0
    if isinstance(db, list):
        for ent in db:
            if not isinstance(ent, dict):
                continue
            d = ent.get("decoded") or {}
            src_name = (d.get("source") or "").split("/")[-1]
            line = d.get("line")
            text = (d.get("source_line_text") or "").strip()
            if not src_name or not line or not text:
                continue
            cur_src = exec_root / "src" / src_name
            if not cur_src.exists():
                continue
            try:
                cur_lines = cur_src.read_text().splitlines()
            except Exception:
                continue
            if 1 <= line <= len(cur_lines):
                cur_text = cur_lines[line - 1].strip()
                if cur_text and text and cur_text != text:
                    stale_evidence = 1.0
                    break
    s["before_shows_stale"] = stale_evidence

    # 3. stale_bundle.txt names a real bundle that exists in dist/
    stale_txt = _read(rd / "stale_bundle.txt").strip().lower()
    bundle_basenames = []
    dist = exec_root / "dist"
    if dist.exists():
        bundle_basenames = [p.name.lower() for p in dist.glob("*.bundle.js")]
    first_tok = (stale_txt.splitlines() or [""])[0].strip().strip('"').strip("'")
    named_real = first_tok in {b for b in bundle_basenames} \
                 or first_tok in {b.split(".")[0] for b in bundle_basenames}
    # Cross-check: the named bundle should also be the one whose
    # sourcesContent length disagrees with current src.
    truly_stale = None
    for bj in bundle_basenames:
        base = bj.split(".")[0]
        mp = dist / f"{base}.bundle.js.map"
        sp = exec_root / "src" / f"{base}.js"
        if mp.exists() and sp.exists():
            try:
                mj = json.loads(mp.read_text())
                sc = (mj.get("sourcesContent") or [""])[0] or ""
                if abs(len(sc.splitlines())
                       - len(sp.read_text().splitlines())) > 4:
                    truly_stale = base
                    break
            except Exception:
                pass
    matches_truth = (truly_stale is not None
                     and first_tok in (truly_stale, f"{truly_stale}.bundle.js"))
    if matches_truth:
        s["stale_bundle_named"] = 1.0
    elif named_real:
        s["stale_bundle_named"] = 0.5
    else:
        s["stale_bundle_named"] = 0.0

    # 4. map_validation.json: any frame must be marked match=false
    mv = {}
    try:
        mv = json.loads(_read(rd / "map_validation.json"))
    except Exception:
        mv = {}
    falsy = [k for k, v in (mv.items() if isinstance(mv, dict) else [])
             if isinstance(v, dict) and v.get("match") is False]
    exactly_one = (len(falsy) == 1)
    points_to_truth = (truly_stale is not None
                       and exactly_one and falsy[0].lower().startswith(truly_stale))
    s["map_validation"] = (1.0 if points_to_truth
                           else 0.5 if exactly_one
                           else 0.2 if falsy else 0.0)

    # 5. diagnosis.md depth
    diag = _read(rd / "diagnosis.md")
    diag_lines = len([ln for ln in diag.splitlines() if ln.strip()])
    diag_subs = len(re.findall(r"(?m)^###\s+\S", diag))
    diag_lower = diag.lower()
    needed = ["sourcescontent", "line", "stale", "rebuild", truly_stale or "feature"]
    hits = sum(1 for w in needed if w in diag_lower)
    s["diagnosis_depth"] = (
        1.0 if (diag_lines >= 25 and diag_subs >= 3 and hits >= 4)
        else 0.5 if (diag_lines >= 18 and diag_subs >= 2 and hits >= 3)
        else 0.0
    )

    # 6. GUI screenshots
    shots = [
        "view_01_console_stack.png",
        "view_02_sources_stale_frame.png",
        "view_03_sources_correct_frame.png",
        "view_04_after_fix_stack.png",
    ]
    present = sum(1 for n in shots if (rd / n).exists())
    s["gui_screens_present"] = present / len(shots)

    ocr_re = re.compile(r"(TypeError|sourcesContent|DevTools|Sources panel|at\s+\w+\s*\()", re.I)
    per_shot = {"view_01_console_stack.png": re.compile(r"TypeError", re.I),
                "view_02_sources_stale_frame.png": re.compile(r"sourcesContent|Sources", re.I),
                "view_04_after_fix_stack.png": re.compile(r"TypeError", re.I)}
    ocr_hits = 0
    if pytesseract and Image:
        for n in shots:
            p = rd / n
            if p.exists():
                try:
                    tx = pytesseract.image_to_string(Image.open(p))
                    needed_re = per_shot.get(n)
                    if needed_re is not None:
                        if needed_re.search(tx):
                            ocr_hits += 1
                    elif ocr_re.search(tx):
                        ocr_hits += 1
                except Exception:
                    pass
        s["gui_screens_ocr"] = ocr_hits / len(shots)
    else:
        s["gui_screens_ocr"] = 0.0

    # 7. After-fix: the bundle the agent named should now have its map's
    # sourcesContent[0] line count match the current src file.
    diff = None
    target_base = None
    for bj in bundle_basenames:
        base = bj.split(".")[0]
        if base in stale_txt:
            target_base = base
            break
    if target_base is None and truly_stale:
        target_base = truly_stale
    if target_base:
        sp = exec_root / "src" / f"{target_base}.js"
        mp = exec_root / "dist" / f"{target_base}.bundle.js.map"
        if sp.exists() and mp.exists():
            try:
                cur_lines = len(sp.read_text().splitlines())
                mj = json.loads(mp.read_text())
                sc = (mj.get("sourcesContent") or [""])[0] or ""
                diff = abs(cur_lines - len(sc.splitlines()))
            except Exception:
                diff = None
    if diff is None:
        s["map_regenerated"] = 0.0
    else:
        s["map_regenerated"] = 1.0 if diff <= 2 else 0.4 if diff <= 8 else 0.0

    # 8. decoded_after.json: the previously-stale frame now decodes to
    # a source line whose text matches the current src/<name>.js at the
    # decoded line number.
    da = {}
    try:
        da = json.loads(_read(rd / "decoded_after.json"))
    except Exception:
        da = {}
    after_ok = 0.0
    if isinstance(da, list) and target_base:
        for ent in da:
            if not isinstance(ent, dict):
                continue
            if target_base not in str(ent.get("input", "")):
                continue
            d = ent.get("decoded") or {}
            src = (d.get("source") or "").split("/")[-1]
            line = d.get("line")
            text = (d.get("source_line_text") or "").strip()
            if src == f"{target_base}.js" and line and text:
                cur_src = exec_root / "src" / src
                if cur_src.exists():
                    cur_lines = cur_src.read_text().splitlines()
                    if 1 <= line <= len(cur_lines):
                        gt_token = "crashHere"
                        if cur_lines[line - 1].strip() == text and gt_token in text:
                            after_ok = max(after_ok, 1.0)
                        elif gt_token in text and text in cur_lines[line - 1]:
                            after_ok = max(after_ok, 0.6)
                        else:
                            after_ok = max(after_ok, 0.0)
    s["after_decodes_correct"] = after_ok

    # 9. VLM rubric
    sample = [str(rd / n) for n in shots if (rd / n).exists()][:4]
    if vlm_score_rubric and sample:
        rubric = {
            "vlm_devtools_real": "至少一张截图清晰显示 Chrome DevTools 真实 UI（左 Files / 右 Sources 编辑器，或顶部 Console 面板）",
            "vlm_stack_visible": "至少一张截图能看到 TypeError 或 stack trace（红色错误链接）",
            "vlm_before_after": "view_04 与 view_01 能体现修复前后差异（行号或源文件指向变化）",
        }
        try:
            vlm = vlm_score_rubric(sample, rubric,
                                   instruction="评估 sourcemap mismatch 调试的 DevTools 截图证据。")
        except Exception:
            vlm = {}
        for k in rubric:
            s[k] = vlm.get(k, 0.0)
        s["judge_method"] = vlm.get("judge_method", "failed")
        vlm_avg = sum(vlm.get(k, 0) for k in rubric) / len(rubric) if vlm else 0.0
    else:
        vlm_avg = 0.3

    # base
    numerics = [v for k, v in s.items()
                if isinstance(v, (int, float)) and k != "judge_method"]
    base = sum(numerics) / max(1, len(numerics))
    overall = round((base + vlm_avg) / 2.0, 3) if vlm_score_rubric else round(base, 3)

    # hard gates
    has_cli_evidence = (
        (rd / "decoded_before.json").exists()
        and (rd / "decoded_after.json").exists()
        and (rd / "diagnosis.md").exists()
    )
    has_gui_screenshot = present >= 2
    if not has_cli_evidence:
        overall = round(min(overall, 0.4), 3)
    # GUI-path scoring axis removed: missing screenshots already cost
    # the screenshots / OCR / vlm_* sub-scores.
    if vlm_score_rubric and vlm_avg < 0.6:
        overall = round(min(overall, 0.45), 3)

    s["overall_score"] = overall
    return s
```

## Workspace Path

```
workspace/WEB/task_15_sourcemap_stack_decode
```

## Skills

```
```

## Env

```
```

## Warmup

```bash
mkdir -p /tmp_workspace/results /tmp_workspace/state /opt/web15_gt && chmod 777 /tmp_workspace/results /tmp_workspace/state
if [ -f /tmp_workspace/gt/expected.json ]; then
  mv /tmp_workspace/gt/expected.json /opt/web15_gt/expected.json 2>/dev/null || cp /tmp_workspace/gt/expected.json /opt/web15_gt/expected.json 2>/dev/null || true
  chown -R root:root /opt/web15_gt 2>/dev/null || true
  chmod 700 /opt/web15_gt 2>/dev/null || true
  chmod 600 /opt/web15_gt/expected.json 2>/dev/null || true
  rm -rf /tmp_workspace/gt 2>/dev/null || true
fi
which curl || (for i in 1 2 3 4 5; do apt-get -o Acquire::Retries=10 update -qq && DEBIAN_FRONTEND=noninteractive apt-get -o Acquire::Retries=10 install -y -qq --fix-missing curl ca-certificates && break; sleep 5; done) || true
which jq || (for i in 1 2 3 4 5; do apt-get -o Acquire::Retries=10 update -qq && DEBIAN_FRONTEND=noninteractive apt-get -o Acquire::Retries=10 install -y -qq --fix-missing jq && break; sleep 5; done) || true
which python3 || (for i in 1 2 3 4 5; do apt-get -o Acquire::Retries=10 update -qq && DEBIAN_FRONTEND=noninteractive apt-get -o Acquire::Retries=10 install -y -qq --fix-missing python3 python3-pip && break; sleep 5; done) || true
which tesseract || (for i in 1 2 3 4 5; do apt-get -o Acquire::Retries=10 update -qq && DEBIAN_FRONTEND=noninteractive apt-get -o Acquire::Retries=10 install -y -qq --fix-missing tesseract-ocr fonts-noto-cjk && break; sleep 5; done) || true
pip3 install --break-system-packages --ignore-installed --quiet blinker 2>/dev/null || pip3 install --ignore-installed --quiet blinker || true
pip3 install --break-system-packages --quiet flask pillow pytesseract requests sourcemap 2>/dev/null || pip3 install --quiet flask pillow pytesseract requests sourcemap || true
chmod +x /tmp_workspace/start.sh 2>/dev/null || true; chmod +x /tmp_workspace/tools/*.py 2>/dev/null || true
nohup bash /tmp_workspace/start.sh >/tmp/start.log 2>&1 & sleep 3; for i in $(seq 1 30); do curl -sf http://localhost:8200/ >/dev/null && break; sleep 1; done
```