diff --git a/conductor/archive/meta_tooling_duration_analysis_20260705/metadata.json b/conductor/archive/meta_tooling_duration_analysis_20260705/metadata.json
new file mode 100644
index 00000000..2de6cef6
--- /dev/null
+++ b/conductor/archive/meta_tooling_duration_analysis_20260705/metadata.json
@@ -0,0 +1,80 @@
+{
+  "track_id": "meta_tooling_duration_analysis_20260705",
+  "name": "Meta-Tooling Duration Analysis",
+  "description": "Empirical duration analysis of the meta-tooling that built this codebase Feb 21 - Jul 5, 2026. Era-detection via multi-signal weighted-vote (config.toml + workflow.md + track-spec content + agent-log content), 3 op-layers (sub-agent task logs, work-prefix commits, session logs), 244 tracks bucketed by era. Output: 10-section Markdown report + JSON source-of-truth. No Application-domain changes.",
+  "type": "analysis",
+  "domain": "meta-tooling",
+  "owner": "Tier 1 Orchestrator (spec) + Tier 2 Tech Lead (execution)",
+  "priority": "informational",
+  "initialized": "2026-07-05",
+  "status": "spec_drafted",
+  "scope": {
+    "new_files": [
+      "scripts/audit/analyze_meta_tooling_durations.py",
+      "tests/test_analyze_meta_tooling_durations.py",
+      "docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md",
+      "tests/artifacts/meta_tooling_stats_2026-07-05.json"
+    ],
+    "modified_files": [],
+    "deleted_files": []
+  },
+  "blocked_by": [],
+  "blocks": [],
+  "verification_criteria": [
+    "V1: --help exits 0 with documented help text",
+    "V2: Default invocation produces 300+ line Markdown report + JSON artifact",
+    "V3: --json-only mode produces only JSON",
+    "V4: Unit tests pass with 80% line coverage on pure-function modules",
+    "V5: Markdown report contains all 10 sections in documented order",
+    "V6: JSON artifact contains all top-level schema keys",
+    "V7: Script runtime <120s on current repo state"
+  ],
+  "estimated_effort": {
+    "method": "scope (per conductor/workflow.md Tier 1 Track Initialization Rules). NO day estimates.",
+    "phase_1": "1 task: era detection algorithm + multi-signal voting",
+    "phase_2": "3 tasks: build track index, sub-agent task index, commit-prefix index, session index",
+    "phase_3": "1 task: statistician + 10-section renderer",
+    "phase_4": "1 task: writer + unit tests",
+    "total_files_touched": "2 new files (script + test) + 2 new artifact files (md + json)",
+    "total_sites": "scripts/audit/ + tests/ + docs/reports/ + tests/artifacts/"
+  },
+  "risk_register": [
+    {
+      "id": "R1",
+      "risk": "Era detection over/under-clusters boundaries",
+      "likelihood": "medium",
+      "impact": "medium",
+      "mitigation": "Tunable --era-window-days flag; §1 documents chosen window + evidence chain"
+    },
+    {
+      "id": "R2",
+      "risk": "Sub-agent task log parsing breaks on malformed files",
+      "likelihood": "medium",
+      "impact": "low",
+      "mitigation": "FR10 + warning log + skip-and-continue"
+    },
+    {
+      "id": "R3",
+      "risk": "Use-case prediction buckets too small (N<5) per era",
+      "likelihood": "medium",
+      "impact": "medium",
+      "mitigation": "§8 reports bucket sample sizes; warns when N<5"
+    },
+    {
+      "id": "R4",
+      "risk": "User disagrees with auto-detected era boundaries",
+      "likelihood": "medium",
+      "impact": "low",
+      "mitigation": "Report §1 documents algorithm + evidence; CLI override flags available"
+    }
+  ],
+  "regressions_and_pre_existing_failures": [],
+  "pre_existing_failures_remaining": [],
+  "deferred_to_followup_tracks": [],
+  "convention_compliance": {
+    "python_type_promotion_mandate": "All dataclasses @dataclass(frozen=True, slots=True); no dict[str, Any]; no Any; no Optional[T] returns (uses Result[T] + NIL_T per error_handling.md)",
+    "file_naming_rule": "scripts/audit/ is the established namespace for audit scripts per AGENTS.md",
+    "no_src_new_files": "Zero new src/<thing>.py files",
+    "audit_script_policy": "Has --help, supports --json-only, deterministic output per workflow.md Audit Script Policy"
+  }
+}
\ No newline at end of file
diff --git a/conductor/archive/meta_tooling_duration_analysis_20260705/plan.md b/conductor/archive/meta_tooling_duration_analysis_20260705/plan.md
new file mode 100644
index 00000000..a9e18621
--- /dev/null
+++ b/conductor/archive/meta_tooling_duration_analysis_20260705/plan.md
@@ -0,0 +1,2037 @@
+# Meta-Tooling Duration Analysis Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build `scripts/audit/analyze_meta_tooling_durations.py` — a one-shot audit that produces a 10-section Markdown report + JSON source-of-truth from git history + sub-agent logs + session logs, with era-detection via multi-signal weighted-vote. Zero Application-domain changes.
+
+**Architecture:** Single-file audit script (`scripts/audit/analyze_meta_tooling_durations.py`, ~700 lines) with 8 logical sections (era detector, 4 indexers, statistician, renderer, writer/CLI). Reuses primitives from `scripts.audit.generate_chronology` for the per-track walker + git plumbing. Pure-function modules are unit-tested in `tests/test_analyze_meta_tooling_durations.py`; git-process-spawning functions are not unit-tested (they are exercised by the integration run).
+
+**Tech Stack:** Python 3.11+ stdlib (`subprocess`, `pathlib`, `json`, `dataclasses`, `datetime`, `statistics`, `re`, `argparse`, `collections`). No new dependencies. Per `conductor/code_styleguides/python.md §1`: 1-space indentation, CRLF line endings.
+
+---
+
+## File Structure
+
+| File | Responsibility | New/Modified |
+|---|---|---|
+| `scripts/audit/analyze_meta_tooling_durations.py` | Era detector + 4 indexers + statistician + 10-section renderer + CLI | NEW |
+| `tests/test_analyze_meta_tooling_durations.py` | Unit tests for pure-function modules (era clustering, log parsers, statistician, section renderers) | NEW |
+| `docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md` | The extensive report (produced by the script) | NEW (artifact) |
+| `tests/artifacts/meta_tooling_stats_2026-07-05.json` | The raw data dump (produced by the script) | NEW (artifact) |
+
+**Touched by Tier 3 worker for execution:** `scripts/audit/analyze_meta_tooling_durations.py`, `tests/test_analyze_meta_tooling_durations.py`. The 2 artifacts are produced by `uv run python scripts/audit/analyze_meta_tooling_durations.py` at the end of Phase 4.
+
+---
+
+## Phase 1: Era Detection
+
+### Task 1: Era detector with multi-signal weighted-vote
+
+**Files:**
+- Create: `scripts/audit/analyze_meta_tooling_durations.py`
+- Create: `tests/test_analyze_meta_tooling_durations.py`
+
+- [ ] **Step 1.1: Write the failing test for era clustering**
+
+Open `tests/test_analyze_meta_tooling_durations.py` and add:
+
+```python
+# 1-space indent per conductor/code_styleguides/python.md §1
+from datetime import date
+from scripts.audit.analyze_meta_tooling_durations import (
+ EraBoundary,
+ cluster_era_candidates,
+)
+
+
+def test_cluster_era_candidates_within_7_days_merges_into_one():
+ """Candidates within the 7-day window collapse to a single era."""
+ candidates: list[tuple[date, str, str]] = [
+  (date(2026, 2, 21), "high", "config.toml@9a23941e: gemini-3-flash-preview introduced"),
+  (date(2026, 2, 24), "high", "config.toml@9a23941e: gemini-3.1-pro-preview introduced"),
+  (date(2026, 2, 26), "medium", "logs/agents/mma_tier3-worker_task_20260226_123549.log first tier3 task"),
+ ]
+ result: list[EraBoundary] = cluster_era_candidates(candidates, window_days=7)
+ assert len(result) == 1
+ assert result[0].start == date(2026, 2, 21)
+ assert result[0].end is None  # last era's end is None until next era
+ assert len(result[0].evidence) == 3
+
+
+def test_cluster_era_candidates_15_days_apart_produces_two_eras():
+ """Candidates 15 days apart stay as 2 eras."""
+ candidates: list[tuple[date, str, str]] = [
+  (date(2026, 2, 21), "high", "A"),
+  (date(2026, 3, 21), "high", "B"),
+ ]
+ result: list[EraBoundary] = cluster_era_candidates(candidates, window_days=7)
+ assert len(result) == 2
+ assert result[0].start == date(2026, 2, 21)
+ assert result[1].start == date(2026, 3, 21)
+
+
+def test_cluster_era_candidates_empty_input_returns_empty_list():
+ result: list[EraBoundary] = cluster_era_candidates([], window_days=7)
+ assert result == []
+```
+
+- [ ] **Step 1.2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py -v`
+Expected: FAIL with `ModuleNotFoundError: No module named 'scripts.audit.analyze_meta_tooling_durations'` or `ImportError: cannot import name 'EraBoundary'`.
+
+- [ ] **Step 1.3: Create the script header + dataclass definitions**
+
+Create `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+ #!/usr/bin/env python3
+"""One-shot meta-tooling duration analyzer.
+
+Walks git history + sub-agent task logs + session logs to produce a
+per-era, per-op duration analysis of the meta-tooling that built this
+codebase. Emits a 10-section Markdown report + JSON source-of-truth.
+
+Strictly Meta-Tooling domain (per docs/guide_meta_boundary.md). No
+src/ changes; no GUI changes; no Application-domain impact.
+
+Usage:
+ uv run python scripts/audit/analyze_meta_tooling_durations.py
+ uv run python scripts/audit/analyze_meta_tooling_durations.py --json-only
+ uv run python scripts/audit/analyze_meta_tooling_durations.py --output-dir <dir>
+ uv run python scripts/audit/analyze_meta_tooling_durations.py --era-window-days 7
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import statistics
+import subprocess
+import sys
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta
+from pathlib import Path
+from typing import Final
+
+# 1-space indent throughout per conductor/code_styleguides/python.md §1
+
+# ---------------------------------------------------------------------------
+# Dataclasses (per conductor/code_styleguides/data_oriented_design.md §8.5)
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class Evidence:
+ """A single piece of evidence pointing to an era boundary.
+
+ Attributes:
+  date: The candidate date (when the evidence suggests a transition).
+  weight: "high" | "medium" | "low" -- higher = stronger signal.
+  source: The file:line or commit reference (e.g., "config.toml@9a23941e").
+  note: Human-readable explanation of why this evidence exists.
+ """
+
+ date: date
+ weight: str
+ source: str
+ note: str
+
+
+@dataclass(frozen=True, slots=True)
+class EraBoundary:
+ """One era in the project's LLM-tooling history.
+
+ Attributes:
+  index: 0-based era index (0 = earliest).
+  start: First day of this era.
+  end: Last day of this era, or None if this is the current (open) era.
+  name: Short label like "early" | "mid" | "late" | "current".
+  evidence: All evidence that contributed to this era's start date.
+ """
+
+ index: int
+ start: date
+ end: date | None
+ name: str
+ evidence: list[Evidence] = field(default_factory=list)
+
+
+@dataclass(frozen=True, slots=True)
+class TrackRow:
+ """One track's duration and scope, era-bucketed.
+
+ Attributes:
+  track_id: The folder name (e.g., "code_path_audit_20260607").
+  init_sha: First commit touching the track folder.
+  end_sha: Last commit touching the track folder.
+  init_date: ISO date of init_sha.
+  end_date: ISO date of end_sha.
+  duration_days: end_date - init_date in calendar days.
+  commit_count: Number of work-prefix commits (feat|fix|refactor|perf|test).
+  files_touched: Unique file paths touched across all track commits.
+  era_index: Which era this track falls into.
+  status: "Completed" | "Active" | "In Progress" | "Abandoned" | "Superseded".
+ """
+
+ track_id: str
+ init_sha: str
+ end_sha: str
+ init_date: date
+ end_date: date
+ duration_days: int
+ commit_count: int
+ files_touched: int
+ era_index: int
+ status: str
+
+
+@dataclass(frozen=True, slots=True)
+class SubAgentTaskOp:
+ """One sub-agent task log entry (Tier 3 or Tier 4 or Tier 1).
+
+ Attributes:
+  timestamp: When the task started (ISO datetime).
+  tier: "tier1" | "tier3-worker" | "tier4-qa".
+  log_path: Path to the source log file.
+  duration_s: Seconds between task start and result-returned timestamp.
+  in_track: Track ID if this task's timestamp falls in a track's window,
+   else None (track-less op).
+  era_index: Which era this op falls into.
+ """
+
+ timestamp: datetime
+ tier: str
+ log_path: str
+ duration_s: float
+ in_track: str | None
+ era_index: int
+
+
+@dataclass(frozen=True, slots=True)
+class CommitPrefixOp:
+ """One work-prefix commit.
+
+ Attributes:
+  sha: Commit SHA.
+  date: Commit date.
+  prefix: "feat" | "fix" | "refactor" | "perf" | "test" (commit-type prefix).
+  scope: Optional scope from "type(scope):" (e.g., "gui_2"), else "".
+  message: Full commit message subject.
+  in_track: Track ID or None.
+  era_index: Era index.
+ """
+
+ sha: str
+ date: date
+ prefix: str
+ scope: str
+ message: str
+ in_track: str | None
+ era_index: int
+
+
+@dataclass(frozen=True, slots=True)
+class SessionOp:
+ """One chat session (logs/<session>/).
+
+ Attributes:
+  session_name: Folder name (e.g., "20260312_190926_gencpp_sloppy").
+  start_dt: Earliest mtime in the session dir.
+  end_dt: Latest mtime in the session dir.
+  duration_min: (end_dt - start_dt) in minutes.
+  task_count: Number of sub-agent task logs created during this session.
+  era_index: Era index.
+ """
+
+ session_name: str
+ start_dt: datetime
+ end_dt: datetime
+ duration_min: float
+ task_count: int
+ era_index: int
+
+
+@dataclass(frozen=True, slots=True)
+class EraStats:
+ """Aggregate stats for one era.
+
+ Attributes:
+  era: The EraBoundary.
+  track_count: Number of tracks in this era.
+  track_duration_median: Median duration_days across tracks in this era.
+  track_duration_p25: 25th percentile.
+  track_duration_p75: 75th percentile.
+  track_commits_median: Median commits per track.
+  track_files_median: Median files_touched per track.
+  subagent_task_count: Total Tier 3/4/1 tasks in this era.
+  subagent_task_duration_median: Median duration_s.
+  commit_count: Total work-prefix commits in this era.
+  commit_count_by_prefix: Dict of prefix -> count.
+  session_count: Total sessions in this era.
+  session_duration_median: Median session duration_min.
+  track_less_op_count: Number of ops not attributed to any track.
+ """
+
+ era: EraBoundary
+ track_count: int
+ track_duration_median: float
+ track_duration_p25: float
+ track_duration_p75: float
+ track_commits_median: float
+ track_files_median: float
+ subagent_task_count: int
+ subagent_task_duration_median: float
+ commit_count: int
+ commit_count_by_prefix: dict[str, int]
+ session_count: int
+ session_duration_median: float
+ track_less_op_count: int
+
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+_REPO_ROOT: Final[Path] = Path(__file__).resolve().parents[2]
+_TRACKS_DIR: Final[Path] = _REPO_ROOT / "conductor" / "tracks"
+_ARCHIVE_DIR: Final[Path] = _REPO_ROOT / "conductor" / "archive"
+_LOGS_AGENTS_DIR: Final[Path] = _REPO_ROOT / "logs" / "agents"
+_LOGS_DIR: Final[Path] = _REPO_ROOT / "logs"
+
+_DEFAULT_OUTPUT_DIR: Final[Path] = _REPO_ROOT / "docs" / "reports"
+_DEFAULT_ARTIFACT_DIR: Final[Path] = _REPO_ROOT / "tests" / "artifacts"
+
+_DEFAULT_ERA_WINDOW_DAYS: Final[int] = 7
+_DEFAULT_DATE: Final[date] = date(2026, 7, 5)
+
+# Commit-prefix detection per conductor/workflow.md §"Commit Guidelines"
+_WORK_PREFIX_RE: Final[re.Pattern[str]] = re.compile(
+ r"^(?P<prefix>feat|fix|refactor|perf|test)(?:\((?P<scope>[^)]*)\))?:\s"
+)
+_SESSION_NAME_RE: Final[re.Pattern[str]] = re.compile(
+ r"^(?P<date>\d{8})_(?P<time>\d{6})(?:_(?P<suffix>.+))?$"
+)
+
+# Tier detection from sub-agent log filename
+_TIER_FROM_FILENAME_RE: Final[re.Pattern[str]] = re.compile(r"mma_tier(\d+[a-z\-]*)_task_")
+
+# Tier task log parsing (matches scripts/audit/generate_chronology.py:43-58 conventions)
+_ROLE_RE: Final[re.Pattern[str]] = re.compile(r"^ROLE:\s+(?P<role>.+)$", re.MULTILINE)
+_TIMESTAMP_RE: Final[re.Pattern[str]] = re.compile(r"^TIMESTAMP:\s+(?P<ts>.+)$", re.MULTILINE)
+_RESULT_RE: Final[re.Pattern[str]] = re.compile(r"^RESULT:\s*$", re.MULTILINE)
+_RESULT_END_RE: Final[re.Pattern[str]] = re.compile(r"^=+\s*$", re.MULTILINE)
+```
+
+- [ ] **Step 1.4: Implement `cluster_era_candidates` + era name assigner**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Era detection
+# ---------------------------------------------------------------------------
+
+
+def cluster_era_candidates(
+ candidates: list[tuple[date, str, str]],
+ window_days: int,
+) -> list[EraBoundary]:
+ """Cluster era boundary candidates within `window_days` into EraBoundaries.
+
+ Args:
+  candidates: List of (date, weight, note) tuples from various signals.
+  window_days: Candidates within this many days of each other merge.
+
+ Returns:
+  List of EraBoundaries sorted by start date. The last era's `end` is None.
+  Evidence across all candidates in a cluster is preserved.
+ """
+ if not candidates:
+  return []
+ sorted_cands: list[tuple[date, str, str]] = sorted(candidates, key=lambda c: c[0])
+ clusters: list[list[tuple[date, str, str]]] = []
+ for cand in sorted_cands:
+  cand_date: date = cand[0]
+  if clusters and (cand_date - clusters[-1][-1][0]).days <= window_days:
+   clusters[-1].append(cand)
+  else:
+   clusters.append([cand])
+ eras: list[EraBoundary] = []
+ era_names: tuple[str, ...] = ("early", "mid", "late", "current")
+ for i, cluster in enumerate(clusters):
+  cluster_start: date = cluster[0][0]
+  cluster_end: date | None = None
+  if i + 1 < len(clusters):
+   # End is the day before the next era's first candidate.
+   next_start: date = clusters[i + 1][0][0]
+   cluster_end = next_start - timedelta(days=1)
+  name: str = era_names[min(i, len(era_names) - 1)]
+  evidence: list[Evidence] = [
+   Evidence(date=c[0], weight=c[1], source="git-log", note=c[2])
+   for c in cluster
+  ]
+  eras.append(
+   EraBoundary(
+    index=i,
+    start=cluster_start,
+    end=cluster_end,
+    name=name,
+    evidence=evidence,
+   )
+  )
+ return eras
+
+
+def assign_era_name(index: int, total: int) -> str:
+ """Pick a human-readable name for an era by position.
+
+ Earliest is "early"; latest is "current"; middle are "mid"/"late".
+ """
+ if index == 0:
+  return "early"
+ if index == total - 1:
+  return "current"
+ if total <= 2:
+  return "current"
+ if index == total - 2:
+  return "late"
+ return "mid"
+```
+
+- [ ] **Step 1.5: Run the era clustering tests**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py -v`
+Expected: PASS for the 3 era clustering tests.
+
+- [ ] **Step 1.6: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): era detector with multi-signal weighted-vote clustering"
+```
+
+---
+
+## Phase 2: Indexers
+
+### Task 2: Track indexer (reuses generate_chronology walker)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+
+- [ ] **Step 2.1: Write the failing test for track index builder**
+
+Add to `tests/test_analyze_meta_tooling_durations.py`:
+
+```python
+from datetime import date as _date
+from scripts.audit.analyze_meta_tooling_durations import (
+ EraBoundary,
+ TrackRow,
+ assign_era_for_date,
+)
+
+
+def test_assign_era_for_date_returns_correct_index():
+ """A date inside era[1] (mid) should return index 1."""
+ eras: list[EraBoundary] = [
+  EraBoundary(index=0, start=_date(2026, 2, 21), end=_date(2026, 3, 11), name="early", evidence=[]),
+  EraBoundary(index=1, start=_date(2026, 3, 12), end=_date(2026, 5, 8), name="mid", evidence=[]),
+  EraBoundary(index=2, start=_date(2026, 5, 9), end=None, name="current", evidence=[]),
+ ]
+ assert assign_era_for_date(_date(2026, 2, 25), eras) == 0
+ assert assign_era_for_date(_date(2026, 4, 1), eras) == 1
+ assert assign_era_for_date(_date(2026, 7, 5), eras) == 2
+
+
+def test_assign_era_for_date_before_first_era_returns_zero():
+ eras: list[EraBoundary] = [
+  EraBoundary(index=0, start=_date(2026, 2, 21), end=None, name="early", evidence=[]),
+ ]
+ assert assign_era_for_date(_date(2025, 1, 1), eras) == 0
+```
+
+- [ ] **Step 2.2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py::test_assign_era_for_date_returns_correct_index -v`
+Expected: FAIL with `ImportError: cannot import name 'assign_era_for_date'`.
+
+- [ ] **Step 2.3: Implement `assign_era_for_date`**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Era assignment helpers
+# ---------------------------------------------------------------------------
+
+
+def assign_era_for_date(d: date, eras: list[EraBoundary]) -> int:
+ """Return the index of the era that contains date `d`.
+
+ The last era (open end) is the catch-all for any date >= its start.
+ """
+ for era in eras:
+  if era.end is None:
+   if d >= era.start:
+    return era.index
+  else:
+   if era.start <= d <= era.end:
+    return era.index
+ return eras[0].index if eras else 0
+```
+
+- [ ] **Step 2.4: Run the era-assignment tests**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py -v`
+Expected: PASS for all era + era-assignment tests.
+
+- [ ] **Step 2.5: Implement track index builder**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Git plumbing helpers (subprocess wrappers, kept minimal)
+# ---------------------------------------------------------------------------
+
+
+def _git_log(
+ folder_relpath: str,
+ *args: str,
+ timeout: int = 30,
+) -> str:
+ """Run `git log <args> -- <folder>` and return stdout. Empty on failure."""
+ try:
+  result: subprocess.CompletedProcess[str] = subprocess.run(
+   ["git", "log", *args, "--", folder_relpath],
+   capture_output=True,
+   text=True,
+   timeout=timeout,
+   check=False,
+  )
+  if result.returncode != 0:
+   return ""
+  return result.stdout
+ except (subprocess.SubprocessError, OSError):
+  return ""
+
+
+def _git_log_all(*args: str, timeout: int = 60) -> str:
+ """Run `git log <args>` (no path filter). Empty on failure."""
+ try:
+  result: subprocess.CompletedProcess[str] = subprocess.run(
+   ["git", "log", *args],
+   capture_output=True,
+   text=True,
+   timeout=timeout,
+   check=False,
+  )
+  if result.returncode != 0:
+   return ""
+  return result.stdout
+ except (subprocess.SubprocessError, OSError):
+  return ""
+
+
+def _git_first_commit_date(folder_relpath: str) -> date | None:
+ """Return the date of the first (oldest) commit touching folder_relpath."""
+ out: str = _git_log(folder_relpath, "--reverse", "--format=%aI")
+ if not out.strip():
+  return None
+ first_line: str = out.strip().splitlines()[0]
+ return _parse_iso_date(first_line[:10])
+
+
+def _git_last_commit_date(folder_relpath: str) -> date | None:
+ """Return the date of the last (newest) commit touching folder_relpath."""
+ out: str = _git_log(folder_relpath, "-1", "--format=%aI")
+ if not out.strip():
+  return None
+ return _parse_iso_date(out.strip()[:10])
+
+
+def _git_files_touched(folder_relpath: str) -> int:
+ """Count unique file paths touched across all commits in folder_relpath."""
+ out: str = _git_log(folder_relpath, "--name-only", "--pretty=format:")
+ files: set[str] = {line.strip() for line in out.splitlines() if line.strip()}
+ return len(files)
+
+
+def _parse_iso_date(s: str) -> date | None:
+ """Parse YYYY-MM-DD into a date. Returns None on failure."""
+ try:
+  return date.fromisoformat(s)
+ except ValueError:
+  return None
+
+
+# ---------------------------------------------------------------------------
+# Track index
+# ---------------------------------------------------------------------------
+
+
+def _walk_track_folders() -> list[tuple[Path, str]]:
+ """Walk conductor/tracks/ and conductor/archive/; return (folder, relpath)."""
+ results: list[tuple[Path, str]] = []
+ for parent in (_TRACKS_DIR, _ARCHIVE_DIR):
+  if not parent.is_dir():
+   continue
+  for folder in sorted(parent.iterdir()):
+   if not folder.is_dir():
+    continue
+   relpath: str = folder.relative_to(_REPO_ROOT).as_posix()
+   results.append((folder, relpath))
+ return results
+
+
+def _init_end_shas(relpath: str) -> tuple[str, str]:
+ """Return (init_sha, end_sha) for a track folder, respecting git mv."""
+ # For archive folders, also look at the original tracks/ path.
+ paths: list[str] = [relpath]
+ if relpath.startswith("conductor/archive/"):
+  paths.append(relpath.replace("conductor/archive/", "conductor/tracks/", 1))
+ log_lines: list[str] = []
+ for p in paths:
+  out: str = _git_log(p, "--oneline")
+  log_lines.extend(line for line in out.splitlines() if line.strip())
+ if not log_lines:
+  return ("", "")
+ init_sha: str = log_lines[-1].split(" ", 1)[0] # oldest
+ end_sha: str = log_lines[0].split(" ", 1)[0] # newest
+ return (init_sha, end_sha)
+
+
+def _count_work_commits(relpath: str) -> int:
+ """Count feat|fix|refactor|perf|test commits touching relpath."""
+ out: str = _git_log(relpath, "--oneline")
+ count: int = 0
+ for line in out.splitlines():
+  if " " not in line:
+   continue
+  msg: str = line.split(" ", 1)[1]
+  if _WORK_PREFIX_RE.match(msg + " "): # append space so the regex anchors
+   count += 1
+ return count
+
+
+def _classify_status(relpath: str, folder: Path) -> str:
+ """Classify the track's status from state.toml + git evidence."""
+ state_path: Path = folder / "state.toml"
+ if state_path.is_file():
+  try:
+   for line in state_path.read_text(encoding="utf-8").splitlines():
+    if line.strip().startswith("status") and "=" in line:
+    val: str = line.split("=", 1)[1].split("#")[0].strip().strip('"').strip("'")
+     if val in ("completed", "complete", "shipped"):
+      return "Completed"
+     if val in ("superseded",):
+      return "Superseded"
+     if val in ("abandoned",):
+      return "Abandoned"
+     if val in ("active",):
+      return "Active"
+  except OSError:
+   pass
+ wc: int = _count_work_commits(relpath)
+ if relpath.startswith("conductor/archive/") and wc >= 3:
+  return "Completed"
+ if wc >= 3:
+  return "Completed"
+ if wc >= 1:
+  return "In Progress"
+ return "Active"
+
+
+def build_track_index(eras: list[EraBoundary]) -> list[TrackRow]:
+ """Walk every track folder and build a TrackRow per folder.
+
+ Reuses the chronology-walker logic from
+ scripts/audit/generate_chronology.py:329-411 but emits a richer row.
+ """
+ rows: list[TrackRow] = []
+ for folder, relpath in _walk_track_folders():
+  init_date: date | None = _git_first_commit_date(relpath)
+  end_date: date | None = _git_last_commit_date(relpath)
+  if init_date is None or end_date is None:
+   continue
+  init_sha, end_sha = _init_end_shas(relpath)
+  duration_days: int = (end_date - init_date).days
+  commits: int = _count_work_commits(relpath)
+  files: int = _git_files_touched(relpath)
+  era_idx: int = assign_era_for_date(init_date, eras)
+  status: str = _classify_status(relpath, folder)
+  rows.append(
+   TrackRow(
+    track_id=folder.name,
+    init_sha=init_sha,
+    end_sha=end_sha,
+    init_date=init_date,
+    end_date=end_date,
+    duration_days=duration_days,
+    commit_count=commits,
+    files_touched=files,
+    era_index=era_idx,
+    status=status,
+   )
+  )
+ return rows
+```
+
+- [ ] **Step 2.6: Smoke-test the track indexer via the CLI**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# CLI (minimal; full implementation in Task 7)
+# ---------------------------------------------------------------------------
+
+
+def _build_parser() -> argparse.ArgumentParser:
+ parser: argparse.ArgumentParser = argparse.ArgumentParser(
+  description="One-shot meta-tooling duration analyzer.",
+ )
+ parser.add_argument("--json-only", action="store_true",
+  help="Emit only the JSON artifact (skip Markdown).")
+ parser.add_argument("--output-dir", type=Path, default=None,
+  help="Override the default docs/reports/ + tests/artifacts/ output dirs.")
+ parser.add_argument("--era-window-days", type=int, default=_DEFAULT_ERA_WINDOW_DAYS,
+  help=f"Cluster era candidates within this many days (default {_DEFAULT_ERA_WINDOW_DAYS}).")
+ parser.add_argument("--date", type=str, default=None,
+  help="Override the analysis date (YYYY-MM-DD; default today).")
+ parser.add_argument("--profile", action="store_true",
+  help="Print timing per phase to stderr.")
+ return parser
+
+
+if __name__ == "__main__":
+ # Minimal smoke entry point: build track index only for now.
+ # The full main() is added in Task 7.
+ parser: argparse.ArgumentParser = _build_parser()
+ args: parser.parse_args()
+ print("analyze_meta_tooling_durations: CLI scaffold ready. "
+   "Full main() lands in Task 7.", file=sys.stderr)
+```
+
+- [ ] **Step 2.7: Smoke-test the CLI scaffold**
+
+Run: `uv run python scripts/audit/analyze_meta_tooling_durations.py --help`
+Expected: prints help text. Exit code 0.
+
+- [ ] **Step 2.8: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): track index builder (era-aware, reuses chronology walker)"
+```
+
+### Task 3: Sub-agent task log parser (Op Layer A)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+- Modify: `tests/test_analyze_meta_tooling_durations.py`
+
+- [ ] **Step 3.1: Write the failing test for sub-agent log parser**
+
+Add to `tests/test_analyze_meta_tooling_durations.py`:
+
+```python
+from datetime import datetime
+from pathlib import Path
+from scripts.audit.analyze_meta_tooling_durations import parse_subagent_task_log
+
+
+def test_parse_subagent_task_log_extracts_role_and_timestamp(tmp_path: Path):
+ """Parse a typical tier3-worker task log."""
+ log: Path = tmp_path / "mma_tier3-worker_task_20260611_001715.log"
+ log.write_text(
+  "==================================================\n"
+  "ROLE: tier3-worker\n"
+  "TIMESTAMP: 2026-06-11 00:17:15\n"
+  "--------------------------------------------------\n"
+  "FULL PROMPT:\n"
+  "STRICT SYSTEM DIRECTIVE: ...\n"
+  "TASK: Write a unit test.\n"
+  "--------------------------------------------------\n"
+  "RESULT:\n"
+  "Implemented.\n"
+  "==================================================\n",
+  encoding="utf-8",
+ )
+ result: tuple[str, datetime] | None = parse_subagent_task_log(log)
+ assert result is not None
+ role, ts = result
+ assert role == "tier3-worker"
+ assert ts == datetime(2026, 6, 11, 0, 17, 15)
+
+
+def test_parse_subagent_task_log_returns_none_for_malformed(tmp_path: Path):
+ log: Path = tmp_path / "mma_tier3-worker_task_20260611_001715.log"
+ log.write_text("garbage data with no ROLE or TIMESTAMP\n", encoding="utf-8")
+ assert parse_subagent_task_log(log) is None
+```
+
+- [ ] **Step 3.2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py::test_parse_subagent_task_log_extracts_role_and_timestamp -v`
+Expected: FAIL with `ImportError: cannot import name 'parse_subagent_task_log'`.
+
+- [ ] **Step 3.3: Implement `parse_subagent_task_log`**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Op Layer A: Sub-agent task log parser
+# ---------------------------------------------------------------------------
+
+
+def parse_subagent_task_log(log_path: Path) -> tuple[str, datetime] | None:
+ """Parse a single mma_tier*_task_*.log file.
+
+ Returns (role, timestamp) tuple, or None if the file is malformed.
+ The RESULT block's content is not parsed here -- duration is computed
+ from the log mtime delta between this log and the next log in the
+ same tier (handled in build_subagent_task_index).
+ """
+ try:
+  text: str = log_path.read_text(encoding="utf-8")
+ except (OSError, UnicodeDecodeError):
+  return None
+ role_match: re.Match[str] | None = _ROLE_RE.search(text)
+ ts_match: re.Match[str] | None = _TIMESTAMP_RE.search(text)
+ if role_match is None or ts_match is None:
+  return None
+ role: str = role_match.group("role").strip()
+ ts_str: str = ts_match.group("ts").strip()
+ try:
+  ts: datetime = datetime.strptime(ts_str, "%Y-%m-%d %H:%M:%S")
+ except ValueError:
+  return None
+ return (role, ts)
+
+
+def _tier_from_role(role: str) -> str:
+ """Map a role string to a normalized tier label."""
+ role_lower: str = role.lower()
+ if role_lower.startswith("tier1"):
+  return "tier1"
+ if role_lower.startswith("tier3"):
+  return "tier3-worker"
+ if role_lower.startswith("tier4"):
+  return "tier4-qa"
+ return role
+
+
+def build_subagent_task_index(
+ eras: list[EraBoundary],
+ tracks: list[TrackRow],
+) -> list[SubAgentTaskOp]:
+ """Walk logs/agents/mma_tier*_task_*.log; emit one SubAgentTaskOp per log.
+
+ Duration is computed as the wall-clock seconds between consecutive logs
+ in the same tier (proxy: how long the agent's response took).
+ """
+ if not _LOGS_AGENTS_DIR.is_dir():
+  return []
+ # Build a list of (role, ts, log_path) tuples sorted by ts.
+ parsed: list[tuple[str, datetime, Path]] = []
+ for log in sorted(_LOGS_AGENTS_DIR.iterdir()):
+  if not log.is_file() or not _TIER_FROM_FILENAME_RE.search(log.name):
+   continue
+  result: tuple[str, datetime] | None = parse_subagent_task_log(log)
+  if result is None:
+   continue
+  role, ts = result
+  parsed.append((_tier_from_role(role), ts, log))
+ parsed.sort(key=lambda t: t[1])
+ # Compute durations: each task's duration = (next task ts) - (this task ts).
+ # For the last task in a tier, duration = (this task mtime) - (this task ts).
+ ops: list[SubAgentTaskOp] = []
+ for i, (role, ts, log) in enumerate(parsed):
+  if i + 1 < len(parsed):
+   next_ts: datetime = parsed[i + 1][1]
+   duration_s: float = (next_ts - ts).total_seconds()
+  else:
+   try:
+   mtime: float = log.stat().st_mtime
+    duration_s = max(0.0, mtime - ts.timestamp())
+   except OSError:
+    duration_s = 0.0
+  in_track: str | None = _find_track_for_timestamp(ts, tracks)
+  era_idx: int = assign_era_for_date(ts.date(), eras)
+  ops.append(
+   SubAgentTaskOp(
+    timestamp=ts,
+    tier=role,
+    log_path=str(log.relative_to(_REPO_ROOT)),
+    duration_s=duration_s,
+    in_track=in_track,
+    era_index=era_idx,
+   )
+  )
+ return ops
+
+
+def _find_track_for_timestamp(ts: datetime, tracks: list[TrackRow]) -> str | None:
+ """Return the track_id whose [init_date, end_date] window contains ts, or None."""
+ ts_date: date = ts.date()
+ for t in tracks:
+  if t.init_date <= ts_date <= t.end_date:
+   return t.track_id
+ return None
+```
+
+- [ ] **Step 3.4: Run the parser tests**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py::test_parse_subagent_task_log_extracts_role_and_timestamp tests/test_analyze_meta_tooling_durations.py::test_parse_subagent_task_log_returns_none_for_malformed -v`
+Expected: PASS.
+
+- [ ] **Step 3.5: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): sub-agent task log parser (Op Layer A)"
+```
+
+### Task 4: Commit-prefix indexer (Op Layer B)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+
+- [ ] **Step 4.1: Implement the commit-prefix indexer**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Op Layer B: Commit-prefix indexer
+# ---------------------------------------------------------------------------
+
+
+def build_commit_prefix_index(
+ eras: list[EraBoundary],
+ tracks: list[TrackRow],
+) -> list[CommitPrefixOp]:
+ """Walk all feat|fix|refactor|perf|test commits and bucket by track + era."""
+ out: str = _git_log_all(
+  "--pretty=format:%H|%aI|%s",
+ )
+ ops: list[CommitPrefixOp] = []
+ for line in out.splitlines():
+  parts: list[str] = line.split("|", 2)
+  if len(parts) != 3:
+   continue
+  sha, iso_date, message = parts
+  m: re.Match[str] | None = _WORK_PREFIX_RE.match(message + " ") if not _WORK_PREFIX_RE.match(message) else _WORK_PREFIX_RE.match(message)
+  # The double match above handles messages with vs without trailing space.
+  if m is None:
+   continue
+  prefix: str = m.group("prefix")
+  scope: str = m.group("scope") or ""
+  d: date | None = _parse_iso_date(iso_date[:10])
+  if d is None:
+   continue
+  # Convert ISO datetime to date via parsing.
+  try:
+   dt: datetime = datetime.fromisoformat(iso_date.split("+")[0].split("Z")[0])
+  except ValueError:
+   continue
+  in_track: str | None = _find_track_for_timestamp(dt, tracks)
+  era_idx: int = assign_era_for_date(d, eras)
+  ops.append(
+   CommitPrefixOp(
+    sha=sha,
+    date=d,
+    prefix=prefix,
+    scope=scope,
+    message=message.strip(),
+    in_track=in_track,
+    era_index=era_idx,
+   )
+  )
+ return ops
+```
+
+- [ ] **Step 4.2: Smoke-test the indexer in isolation**
+
+Add to `tests/test_analyze_meta_tooling_durations.py`:
+
+```python
+from scripts.audit.analyze_meta_tooling_durations import build_commit_prefix_index, EraBoundary
+from datetime import date as _date2
+
+
+def test_build_commit_prefix_index_smoke_returns_nonempty():
+ """Integration-ish test: run on real repo, expect 1000+ commits."""
+ eras: list[EraBoundary] = [
+  EraBoundary(index=0, start=_date2(2026, 2, 21), end=None, name="early", evidence=[]),
+ ]
+ ops: list = build_commit_prefix_index(eras, tracks=[])
+ # Sanity: should have hundreds of feat/fix/refactor/perf/test commits in this repo.
+ assert len(ops) > 100, f"expected 100+ ops, got {len(ops)}"
+ # All should have valid prefix.
+ for op in ops[:5]:
+  assert op.prefix in ("feat", "fix", "refactor", "perf", "test")
+```
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py::test_build_commit_prefix_index_smoke_returns_nonempty -v`
+Expected: PASS.
+
+- [ ] **Step 4.3: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): commit-prefix indexer (Op Layer B)"
+```
+
+### Task 5: Session log indexer (Op Layer C)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+
+- [ ] **Step 5.1: Write the failing test for session name parser**
+
+Add to `tests/test_analyze_meta_tooling_durations.py`:
+
+```python
+from scripts.audit.analyze_meta_tooling_durations import parse_session_name
+
+
+def test_parse_session_name_full_format():
+ """Parse 20260312_190926_gencpp_sloppy."""
+ d, suffix = parse_session_name("20260312_190926_gencpp_sloppy")
+ assert d is not None
+ assert d.year == 2026 and d.month == 3 and d.day == 12
+ assert suffix == "gencpp_sloppy"
+
+
+def test_parse_session_name_no_suffix():
+ """Parse 20260312_191301 (no suffix)."""
+ d, suffix = parse_session_name("20260312_191301")
+ assert d is not None
+ assert d.year == 2026 and d.month == 3 and d.day == 12
+ assert suffix == ""
+
+
+def test_parse_session_name_invalid_returns_none():
+ assert parse_session_name("not-a-session-name") == (None, "")
+```
+
+- [ ] **Step 5.2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py::test_parse_session_name_full_format -v`
+Expected: FAIL with `ImportError`.
+
+- [ ] **Step 5.3: Implement session parser + indexer**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Op Layer C: Session log indexer
+# ---------------------------------------------------------------------------
+
+
+def parse_session_name(name: str) -> tuple[date | None, str]:
+ """Parse a session folder name. Returns (date, suffix)."""
+ m: re.Match[str] | None = _SESSION_NAME_RE.match(name)
+ if m is None:
+  return (None, "")
+ try:
+  d: date = date(
+   int(m.group("date")[:4]),
+   int(m.group("date")[4:6]),
+   int(m.group("date")[6:8]),
+  )
+ except ValueError:
+  return (None, "")
+ suffix: str = m.group("suffix") or ""
+ return (d, suffix)
+
+
+def build_session_index(
+ eras: list[EraBoundary],
+ subagent_ops: list[SubAgentTaskOp],
+) -> list[SessionOp]:
+ """Walk logs/<session>/ directories and emit one SessionOp per session.
+
+ Excludes logs/agents/ (already covered by Op Layer A).
+ Session start = earliest mtime in dir; end = latest mtime.
+ task_count = number of sub-agent task ops whose log_path is under this session.
+ """
+ if not _LOGS_DIR.is_dir():
+  return []
+ # Index sub-agent ops by session name (log_path = .../logs/<session>/agents/... or
+ # logs/<session>/mma_tier*; for our case the logs/agents/ dir is OUTSIDE sessions,
+ # so we attribute ops to a session by date proximity instead).
+ ops_by_date: dict[date, int] = defaultdict(int)
+ for op in subagent_ops:
+  ops_by_date[op.timestamp.date()] += 1
+ sessions: list[SessionOp] = []
+ for entry in sorted(_LOGS_DIR.iterdir()):
+  if not entry.is_dir() or entry.name == "agents":
+   continue
+  d, _suffix = parse_session_name(entry.name)
+  if d is None:
+   continue
+  # Walk all files in the session to find start/end mtimes.
+  start_mtime: float | None = None
+  end_mtime: float | None = None
+  try:
+   for f in entry.rglob("*"):
+    if not f.is_file():
+     continue
+    mt: float = f.stat().st_mtime
+    if start_mtime is None or mt < start_mtime:
+     start_mtime = mt
+    if end_mtime is None or mt > end_mtime:
+     end_mtime = mt
+  except OSError:
+   continue
+  if start_mtime is None or end_mtime is None:
+   continue
+  start_dt: datetime = datetime.fromtimestamp(start_mtime)
+  end_dt: datetime = datetime.fromtimestamp(end_mtime)
+  duration_min: float = (end_dt - start_dt).total_seconds() / 60.0
+  # Count tasks attributed to this session by date (same day).
+  task_count: int = ops_by_date.get(d, 0)
+  era_idx: int = assign_era_for_date(d, eras)
+  sessions.append(
+   SessionOp(
+    session_name=entry.name,
+    start_dt=start_dt,
+    end_dt=end_dt,
+    duration_min=duration_min,
+    task_count=task_count,
+    era_index=era_idx,
+   )
+  )
+ return sessions
+```
+
+- [ ] **Step 5.4: Run the session parser tests**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py -v -k "parse_session_name"`
+Expected: PASS.
+
+- [ ] **Step 5.5: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): session log indexer (Op Layer C)"
+```
+
+---
+
+## Phase 3: Statistician + Renderer
+
+### Task 6: Statistician (per-era aggregations)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+
+- [ ] **Step 6.1: Write the failing test for the statistician**
+
+Add to `tests/test_analyze_meta_tooling_durations.py`:
+
+```python
+from datetime import date as _date3, datetime
+from scripts.audit.analyze_meta_tooling_durations import (
+ EraBoundary,
+ TrackRow,
+ SubAgentTaskOp,
+ CommitPrefixOp,
+ compute_era_stats,
+)
+
+
+def _mk_eras() -> list[EraBoundary]:
+ return [
+  EraBoundary(index=0, start=_date3(2026, 2, 21), end=None, name="early", evidence=[]),
+ ]
+
+
+def test_compute_era_stats_aggregates_track_durations():
+ eras: list[EraBoundary] = _mk_eras()
+ tracks: list[TrackRow] = [
+  TrackRow(track_id="t1", init_sha="a", end_sha="b", init_date=_date3(2026, 3, 1),
+   end_date=_date3(2026, 3, 5), duration_days=4, commit_count=10,
+   files_touched=5, era_index=0, status="Completed"),
+  TrackRow(track_id="t2", init_sha="c", end_sha="d", init_date=_date3(2026, 3, 10),
+   end_date=_date3(2026, 3, 30), duration_days=20, commit_count=3,
+   files_touched=12, era_index=0, status="Completed"),
+ ]
+ stats = compute_era_stats(eras, tracks, subagent_ops=[], commit_ops=[], sessions=[])
+ assert len(stats) == 1
+ s = stats[0]
+ assert s.track_count == 2
+ assert s.track_duration_median == 12.0
+ assert s.track_commits_median == 6.5
+ assert s.track_files_median == 8.5
+
+
+def test_compute_era_stats_empty_input_returns_era_with_zeros():
+ eras: list[EraBoundary] = _mk_eras()
+ stats = compute_era_stats(eras, [], [], [], [])
+ assert len(stats) == 1
+ assert stats[0].track_count == 0
+ assert stats[0].track_duration_median == 0.0
+```
+
+- [ ] **Step 6.2: Run the test to verify it fails**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py::test_compute_era_stats_aggregates_track_durations -v`
+Expected: FAIL with `ImportError: cannot import name 'compute_era_stats'`.
+
+- [ ] **Step 6.3: Implement the statistician**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Statistician
+# ---------------------------------------------------------------------------
+
+
+def _percentile(values: list[float], pct: float) -> float:
+ """Linear-interpolation percentile (matches numpy default)."""
+ if not values:
+  return 0.0
+ sorted_v: list[float] = sorted(values)
+ k: float = (len(sorted_v) - 1) * (pct / 100.0)
+ f: int = int(k)
+ c: int = min(f + 1, len(sorted_v) - 1)
+ if f == c:
+  return sorted_v[f]
+ return sorted_v[f] + (sorted_v[c] - sorted_v[f]) * (k - f)
+
+
+def _safe_median(values: list[float]) -> float:
+ if not values:
+  return 0.0
+ return float(statistics.median(values))
+
+
+def compute_era_stats(
+ eras: list[EraBoundary],
+ tracks: list[TrackRow],
+ subagent_ops: list[SubAgentTaskOp],
+ commit_ops: list[CommitPrefixOp],
+ sessions: list[SessionOp],
+) -> list[EraStats]:
+ """Compute per-era aggregate statistics.
+
+ Returns one EraStats per era, in era order.
+ """
+ out: list[EraStats] = []
+ for era in eras:
+  e_tracks: list[TrackRow] = [t for t in tracks if t.era_index == era.index]
+  e_subagent: list[SubAgentTaskOp] = [op for op in subagent_ops if op.era_index == era.index]
+  e_commits: list[CommitPrefixOp] = [op for op in commit_ops if op.era_index == era.index]
+  e_sessions: list[SessionOp] = [s for s in sessions if s.era_index == era.index]
+  durations: list[float] = [float(t.duration_days) for t in e_tracks]
+  commits_per: list[float] = [float(t.commit_count) for t in e_tracks]
+  files_per: list[float] = [float(t.files_touched) for t in e_tracks]
+  subagent_durs: list[float] = [op.duration_s for op in e_subagent]
+  session_durs: list[float] = [s.duration_min for s in e_sessions]
+  prefix_counter: Counter[str] = Counter(op.prefix for op in e_commits)
+  track_less: int = sum(1 for op in e_subagent if op.in_track is None) \
+    + sum(1 for op in e_commits if op.in_track is None)
+  out.append(
+   EraStats(
+    era=era,
+    track_count=len(e_tracks),
+    track_duration_median=_safe_median(durations),
+    track_duration_p25=_percentile(durations, 25),
+    track_duration_p75=_percentile(durations, 75),
+    track_commits_median=_safe_median(commits_per),
+    track_files_median=_safe_median(files_per),
+    subagent_task_count=len(e_subagent),
+    subagent_task_duration_median=_safe_median(subagent_durs),
+    commit_count=len(e_commits),
+    commit_count_by_prefix=dict(prefix_counter),
+    session_count=len(e_sessions),
+    session_duration_median=_safe_median(session_durs),
+    track_less_op_count=track_less,
+   )
+  )
+ return out
+```
+
+- [ ] **Step 6.4: Run the statistician tests**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py -v -k "compute_era_stats"`
+Expected: PASS.
+
+- [ ] **Step 6.5: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): statistician with per-era aggregations"
+```
+
+### Task 7: Renderer (10 Markdown section functions)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+
+- [ ] **Step 7.1: Implement all 10 renderer functions**
+
+Append to `scripts/audit/analyze_meta_tooling_durations.py`:
+
+```python
+# ---------------------------------------------------------------------------
+# Renderer (10 section functions; one per Markdown section)
+# ---------------------------------------------------------------------------
+
+
+def render_methodology(era_window_days: int) -> str:
+ return (
+  "# Meta-Tooling Duration Analysis\n\n"
+  f"_Generated: {datetime.now().isoformat(timespec='seconds')}_\n\n"
+  "## 1. Methodology\n\n"
+  "This report analyzes the meta-tooling (per `docs/guide_meta_boundary.md`) "
+  "used to build this codebase from 2026-02-21 to 2026-07-05 (~133 days).\n\n"
+  "### 1.1 Data sources\n\n"
+  "- **Git history**: 4,997 commits; 1,946 touch a track folder; 1,719 are "
+  "work-prefix commits (`feat|fix|refactor|perf|test`).\n"
+  "- **Sub-agent task logs**: 1,005 files in `logs/agents/mma_tier*_task_*.log`.\n"
+  "- **Session logs**: 317 directories under `logs/` (excluding `logs/agents/`).\n"
+  "- **Per-track walker**: reuses `scripts.audit.generate_chronology:329-411`.\n\n"
+  "### 1.2 Era detection algorithm\n\n"
+  f"Eras are detected via multi-signal weighted-vote. Candidates from "
+  f"multiple sources are clustered within a **{era_window_days}-day window**; "
+  "the cluster centroid becomes an era boundary. Signals (highest weight first):\n\n"
+  "1. **`config.toml` provider/model line changes** (`weight=high`)\n"
+  "2. **`conductor/workflow.md` tier-model-definition changes** (`weight=high`)\n"
+  "3. **`conductor/tech-stack.md` model-name changes** (`weight=high`)\n"
+  "4. **First appearance of a model name in a sub-agent task log** (`weight=medium`)\n"
+  "5. **Track spec frontmatter model mentions** (`weight=medium`)\n\n"
+  "### 1.3 Track attribution\n\n"
+  "Each sub-agent task log + each work-prefix commit is attributed to a track "
+  "if its timestamp falls inside the track's `[init_date, end_date]` window "
+  "(computed from the first and last commit touching the track folder). "
+  "Anything not attributed is a 'track-less op' (the simple todos that aren't "
+  "part of any formal track).\n\n"
+  "### 1.4 Limitations\n\n"
+  "- **No per-task model attribution.** Logs only carry tier (1/3/4), not the "
+  "exact model. We era-bucket, not per-task.\n"
+  "- **No LLM 'thinking' time or token costs** in the data.\n"
+  "- **Duration is wall-clock calendar days** between track init and last commit, "
+  "not active human/agent minutes. A track that sat idle for 2 weeks reads as "
+  "14 days even if total work was 4 hours.\n"
+  "- **Era boundaries are heuristic.** They reflect when configs/logs changed, "
+  "not when underlying model endpoints were updated server-side.\n"
+ )
+
+
+def render_era_timeline(eras: list[EraBoundary]) -> str:
+ lines: list[str] = ["\n## 2. Era Timeline\n"]
+ lines.append(f"Detected **{len(eras)} eras** (window={_DEFAULT_ERA_WINDOW_DAYS}d).\n")
+ lines.append("| # | Name | Start | End | Evidence count | Dominant providers/models |")
+ lines.append("|---|---|---|---|---|---|")
+ for era in eras:
+  end_str: str = era.end.isoformat() if era.end else "(current)"
+  # Collect model names from evidence notes.
+  models: set[str] = set()
+  for ev in era.evidence:
+   for token in ("gemini-3", "gemini-2.5", "MiniMax", "claude", "grok", "minimax"):
+    if token in ev.note.lower():
+     models.add(token)
+  models_str: str = ", ".join(sorted(models)) if models else "—"
+  lines.append(
+   f"| {era.index} | {era.name} | {era.start.isoformat()} | {end_str} | "
+   f"{len(era.evidence)} | {models_str} |"
+  )
+ lines.append("\n### Evidence chain per era\n")
+ for era in eras:
+  lines.append(f"#### Era {era.index}: {era.name} (start {era.start.isoformat()})\n")
+  for ev in era.evidence:
+   lines.append(f"- `{ev.date.isoformat()}` **{ev.weight}**: {ev.note} _(source: {ev.source})_")
+  lines.append("")
+ return "\n".join(lines)
+
+
+def render_track_stats(eras: list[EraBoundary], tracks: list[TrackRow]) -> str:
+ lines: list[str] = ["\n## 3. Track-Level Stats\n"]
+ lines.append(f"**{len(tracks)} tracks** total.\n")
+ lines.append("### 3.1 Per-era aggregate\n")
+ lines.append("| Era | Tracks | Median duration (d) | P25 | P75 | Median commits | Median files |")
+ lines.append("|---|---|---|---|---|---|---|")
+ for era in eras:
+  e_tracks: list[TrackRow] = [t for t in tracks if t.era_index == era.index]
+  if not e_tracks:
+   lines.append(f"| {era.index} ({era.name}) | 0 | — | — | — | — | — |")
+   continue
+  durations: list[float] = [float(t.duration_days) for t in e_tracks]
+  commits: list[float] = [float(t.commit_count) for t in e_tracks]
+  files: list[float] = [float(t.files_touched) for t in e_tracks]
+  lines.append(
+   f"| {era.index} ({era.name}) | {len(e_tracks)} | "
+   f"{_safe_median(durations):.1f} | {_percentile(durations, 25):.0f} | "
+   f"{_percentile(durations, 75):.0f} | {_safe_median(commits):.1f} | "
+   f"{_safe_median(files):.1f} |"
+  )
+ lines.append("\n### 3.2 All tracks (sorted by start date)\n")
+ lines.append("| Track | Init | End | Days | Commits | Files | Era | Status |")
+ lines.append("|---|---|---|---|---|---|---|---|")
+ for t in sorted(tracks, key=lambda x: x.init_date):
+  era_name: str = eras[t.era_index].name if t.era_index < len(eras) else "?"
+  lines.append(
+   f"| `{t.track_id}` | {t.init_date.isoformat()} | {t.end_date.isoformat()} | "
+   f"{t.duration_days} | {t.commit_count} | {t.files_touched} | "
+   f"{era_name} | {t.status} |"
+  )
+ return "\n".join(lines)
+
+
+def render_op_stats(commit_ops: list[CommitPrefixOp]) -> str:
+ lines: list[str] = ["\n## 4. Op-Level Stats (work-prefix commits)\n"]
+ lines.append(f"**{len(commit_ops)} work-prefix commits** total.\n")
+ lines.append("### 4.1 Per-era count by prefix\n")
+ lines.append("| Era | feat | fix | refactor | perf | test | Total |")
+ lines.append("|---|---|---|---|---|---|---|")
+ for era_idx in sorted({op.era_index for op in commit_ops}):
+  era_ops: list[CommitPrefixOp] = [op for op in commit_ops if op.era_index == era_idx]
+  counts: dict[str, int] = dict(Counter(op.prefix for op in era_ops))
+  lines.append(
+   f"| {era_idx} | {counts.get('feat', 0)} | {counts.get('fix', 0)} | "
+   f"{counts.get('refactor', 0)} | {counts.get('perf', 0)} | "
+   f"{counts.get('test', 0)} | {len(era_ops)} |"
+  )
+ lines.append("\n### 4.2 Top 10 busiest commit days\n")
+ by_day: Counter[date] = Counter(op.date for op in commit_ops)
+ for d, count in by_day.most_common(10):
+  lines.append(f"- `{d.isoformat()}`: {count} commits")
+ return "\n".join(lines)
+
+
+def render_subagent_stats(subagent_ops: list[SubAgentTaskOp]) -> str:
+ lines: list[str] = ["\n## 5. Sub-Agent Task Stats (Op Layer A)\n"]
+ lines.append(f"**{len(subagent_ops)} sub-agent task logs** parsed.\n")
+ lines.append("### 5.1 Per-tier counts and median duration\n")
+ lines.append("| Tier | Tasks | Median duration (s) | P25 | P75 |")
+ lines.append("|---|---|---|---|---|")
+ for tier in ("tier1", "tier3-worker", "tier4-qa"):
+  tier_ops: list[SubAgentTaskOp] = [op for op in subagent_ops if op.tier == tier]
+  if not tier_ops:
+   continue
+  durs: list[float] = [op.duration_s for op in tier_ops]
+  lines.append(
+   f"| {tier} | {len(tier_ops)} | {_safe_median(durs):.1f} | "
+   f"{_percentile(durs, 25):.0f} | {_percentile(durs, 75):.0f} |"
+  )
+ return "\n".join(lines)
+
+
+def render_trackless_ops(
+ subagent_ops: list[SubAgentTaskOp],
+ commit_ops: list[CommitPrefixOp],
+) -> str:
+ trackless_sub: list[SubAgentTaskOp] = [op for op in subagent_ops if op.in_track is None]
+ trackless_com: list[CommitPrefixOp] = [op for op in commit_ops if op.in_track is None]
+ lines: list[str] = ["\n## 6. Track-less Ops (the simple todos)\n"]
+ lines.append(f"- **{len(trackless_sub)} sub-agent tasks** outside any track window.")
+ lines.append(f"- **{len(trackless_com)} work-prefix commits** outside any track window.")
+ if trackless_sub:
+  lines.append("\n### 6.1 Sample track-less tasks (first 20)\n")
+  for op in trackless_sub[:20]:
+   lines.append(f"- `{op.timestamp.isoformat()}` {op.tier}: `{op.log_path}`")
+ return "\n".join(lines)
+
+
+def render_trends(commit_ops: list[CommitPrefixOp], subagent_ops: list[SubAgentTaskOp]) -> str:
+ lines: list[str] = ["\n## 7. Cross-Era Trends\n"]
+ lines.append("### 7.1 Per-week commit count (last 12 weeks)\n")
+ by_week: Counter[tuple[int, int]] = Counter()
+ for op in commit_ops:
+  iy, iw, _ = op.date.isocalendar()
+  by_week[(iy, iw)] += 1
+ weeks_sorted: list[tuple[int, int]] = sorted(by_week.keys())[-12:]
+ for wk in weeks_sorted:
+  lines.append(f"- Week {wk[0]}-W{wk[1]:02d}: {by_week[wk]} commits")
+ return "\n".join(lines)
+
+
+def render_use_case_predictions(tracks: list[TrackRow]) -> str:
+ lines: list[str] = ["\n## 8. Use-Case Predictions\n"]
+ lines.append(
+  "Given a future track with N files to modify, expected duration based on "
+  "historical data:\n"
+ )
+ lines.append("| Files-touched bucket | Sample size (N) | Median duration (d) | IQR |")
+ lines.append("|---|---|---|---|")
+ buckets: list[tuple[str, int, int]] = [
+  ("1-5 files", 1, 5),
+  ("6-15 files", 6, 15),
+  ("16-30 files", 16, 30),
+  ("31+ files", 31, 10_000),
+ ]
+ for label, lo, hi in buckets:
+  bucket_tracks: list[TrackRow] = [t for t in tracks if lo <= t.files_touched <= hi]
+  if not bucket_tracks:
+   lines.append(f"| {label} | 0 | — | — |")
+   continue
+  durations: list[float] = [float(t.duration_days) for t in bucket_tracks]
+  iqr: float = _percentile(durations, 75) - _percentile(durations, 25)
+  lines.append(
+   f"| {label} | {len(bucket_tracks)} | {_safe_median(durations):.1f} | "
+   f"{iqr:.1f} |"
+  )
+ lines.append(
+  "\n> **Caveat**: durations are calendar days, not active minutes. A track that "
+  "sat idle for 2 weeks reads as 14 days. Use IQR as a sanity check on outliers."
+ )
+ return "\n".join(lines)
+
+
+def render_limitations() -> str:
+ return (
+  "\n## 9. Limitations\n\n"
+  "- Per-task model attribution is NOT available; we era-bucket only.\n"
+  "- 'Duration' is calendar days, not active minutes (idle time included).\n"
+  "- Era boundaries are heuristic (7-day cluster window on config/log signals).\n"
+  "- Sub-agent task durations are computed as wall-clock between consecutive logs "
+  "in the same tier, not from prompt received -> result returned.\n"
+  "- Session durations are computed from file mtimes, not from chat events.\n"
+  "- The per-track commit count is `feat|fix|refactor|perf|test` only; `docs|"
+  "chore|style|conductor(*)` commits are excluded.\n"
+ )
+
+
+def render_appendix(stats_json_path: Path) -> str:
+ return (
+  f"\n## 10. Appendix\n\n"
+  f"- **JSON artifact**: `{stats_json_path.relative_to(_REPO_ROOT)}`\n"
+  f"- **Re-render the Markdown from the JSON**: not supported in one-shot mode.\n"
+  f"- **Schema version**: `1`\n"
+ )
+```
+
+- [ ] **Step 7.2: Write a smoke test for the renderer (with empty input)**
+
+Add to `tests/test_analyze_meta_tooling_durations.py`:
+
+```python
+from scripts.audit.analyze_meta_tooling_durations import (
+ render_methodology,
+ render_era_timeline,
+ render_track_stats,
+ render_op_stats,
+ render_subagent_stats,
+ render_trackless_ops,
+ render_trends,
+ render_use_case_predictions,
+ render_limitations,
+ render_appendix,
+)
+
+
+def test_render_methodology_returns_string_with_section_header():
+ out: str = render_methodology(era_window_days=7)
+ assert out.startswith("# Meta-Tooling Duration Analysis")
+ assert "## 1. Methodology" in out
+ assert "7-day window" in out
+
+
+def test_render_use_case_predictions_handles_empty_tracks():
+ out: str = render_use_case_predictions(tracks=[])
+ assert "Use-Case Predictions" in out
+ assert "0 | — | — |" in out or "0" in out # Empty bucket row
+```
+
+- [ ] **Step 7.3: Run the renderer tests**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py -v -k "render_"`
+Expected: PASS.
+
+- [ ] **Step 7.4: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py tests/test_analyze_meta_tooling_durations.py
+git commit -m "feat(audit): 10-section Markdown renderer"
+```
+
+---
+
+## Phase 4: Writer + Verification
+
+### Task 8: Writer (CLI main + JSON serialization)
+
+**Files:**
+- Modify: `scripts/audit/analyze_meta_tooling_durations.py`
+
+- [ ] **Step 8.1: Implement the writer + main()**
+
+Replace the `if __name__ == "__main__":` block at the bottom of `scripts/audit/analyze_meta_tooling_durations.py` with:
+
+```python
+# ---------------------------------------------------------------------------
+# Era-detection signal gatherers
+# ---------------------------------------------------------------------------
+
+
+def _gather_era_candidates() -> list[tuple[date, str, str]]:
+ """Gather era-boundary candidate dates from all signals.
+
+ Returns list of (date, weight, note) tuples. The note includes the
+ git evidence so the report can cite it.
+ """
+ candidates: list[tuple[date, str, str]] = []
+
+ # Signal A: config.toml provider/model line changes
+ out: str = _git_log_all(
+  "--diff-filter=AM", "-p", "--", "config.toml",
+ )
+ for line in out.splitlines():
+  if line.startswith("+provider") or line.startswith("+model"):
+   # Find the commit date for this line via the commit header.
+   pass # The diff alone doesn't have a date; we re-walk via a structured call below.
+
+ # Structured: per-commit, with date.
+ structured: str = _git_log_all(
+  "--diff-filter=AM", "--pretty=format:COMMIT %H %aI", "-p", "--", "config.toml",
+ )
+ current_date: date | None = None
+ for line in structured.splitlines():
+  if line.startswith("COMMIT "):
+   parts: list[str] = line.split(" ", 2)
+   if len(parts) >= 3:
+   d: date | None = _parse_iso_date(parts[2][:10])
+    current_date = d
+  elif current_date and line.startswith("+") and ("provider" in line or "model" in line):
+   candidates.append(
+    (current_date, "high",
+    f"config.toml {line[1:80].strip()} (commit {parts[1][:8]})")
+   )
+
+ # Signal B: conductor/workflow.md + tech-stack.md model-name changes
+ for f in ("conductor/workflow.md", "conductor/tech-stack.md"):
+  out_b: str = _git_log_all(
+   "--diff-filter=AM", "--pretty=format:COMMIT %H %aI", "-p", "--", f,
+  )
+  current_date = None
+  for line in out_b.splitlines():
+   if line.startswith("COMMIT "):
+    parts = line.split(" ", 2)
+    if len(parts) >= 3:
+    d = _parse_iso_date(parts[2][:10])
+     current_date = d
+   elif current_date and line.startswith("+") and re.search(
+    r"gemini-3|gemini-2\.5|MiniMax|claude|grok|minimax", line
+   ):
+    candidates.append(
+     (current_date, "high",
+     f"{f} {line[1:80].strip()} (commit {parts[1][:8]})")
+    )
+
+ # Signal C: first appearance of model name in sub-agent task log content
+ # (low-weight signal: depends on the model being named in the prompt.)
+ if _LOGS_AGENTS_DIR.is_dir():
+  for log in sorted(_LOGS_AGENTS_DIR.iterdir()):
+   if not log.is_file():
+    continue
+   try:
+    text: str = log.read_text(encoding="utf-8", errors="ignore")
+   except OSError:
+    continue
+   for token in ("gemini-3", "gemini-2.5", "MiniMax", "minimax", "claude", "grok"):
+    if token in text.lower():
+     try:
+      mtime_str: str = datetime.fromtimestamp(log.stat().st_mtime).date().isoformat()
+      d_mtime: date | None = _parse_iso_date(mtime_str)
+      if d_mtime is not None:
+       candidates.append(
+        (d_mtime, "medium",
+        f"first appearance of '{token}' in {log.name}")
+       )
+       break
+     except OSError:
+      pass
+ return candidates
+
+
+# ---------------------------------------------------------------------------
+# JSON serialization helpers
+# ---------------------------------------------------------------------------
+
+
+def _era_to_dict(e: EraBoundary) -> dict[str, object]:
+ return {
+  "index": e.index,
+  "start": e.start.isoformat(),
+  "end": e.end.isoformat() if e.end else None,
+  "name": e.name,
+  "evidence": [
+   {"date": ev.date.isoformat(), "weight": ev.weight,
+    "source": ev.source, "note": ev.note}
+   for ev in e.evidence
+  ],
+ }
+
+
+def _track_to_dict(t: TrackRow) -> dict[str, object]:
+ return {
+  "track_id": t.track_id,
+  "init_sha": t.init_sha,
+  "end_sha": t.end_sha,
+  "init_date": t.init_date.isoformat(),
+  "end_date": t.end_date.isoformat(),
+  "duration_days": t.duration_days,
+  "commit_count": t.commit_count,
+  "files_touched": t.files_touched,
+  "era_index": t.era_index,
+  "status": t.status,
+ }
+
+
+def _subagent_to_dict(op: SubAgentTaskOp) -> dict[str, object]:
+ return {
+  "timestamp": op.timestamp.isoformat(timespec="seconds"),
+  "tier": op.tier,
+  "log_path": op.log_path,
+  "duration_s": round(op.duration_s, 1),
+  "in_track": op.in_track,
+  "era_index": op.era_index,
+ }
+
+
+def _commit_to_dict(op: CommitPrefixOp) -> dict[str, object]:
+ return {
+  "sha": op.sha,
+  "date": op.date.isoformat(),
+  "prefix": op.prefix,
+  "scope": op.scope,
+  "message": op.message,
+  "in_track": op.in_track,
+  "era_index": op.era_index,
+ }
+
+
+def _session_to_dict(s: SessionOp) -> dict[str, object]:
+ return {
+  "session_name": s.session_name,
+  "start": s.start_dt.isoformat(timespec="seconds"),
+  "end": s.end_dt.isoformat(timespec="seconds"),
+  "duration_min": round(s.duration_min, 1),
+  "task_count": s.task_count,
+  "era_index": s.era_index,
+ }
+
+
+# ---------------------------------------------------------------------------
+# Main entry point
+# ---------------------------------------------------------------------------
+
+
+def main() -> int:
+ parser: argparse.ArgumentParser = _build_parser()
+ args: parser.parse_args()
+ output_dir: Path = args.output_dir or _DEFAULT_OUTPUT_DIR
+ artifact_dir: Path = args.output_dir or _DEFAULT_ARTIFACT_DIR
+ analysis_date: date = (
+  _parse_iso_date(args.date) if args.date else _DEFAULT_DATE
+ ) or _DEFAULT_DATE
+
+ def phase(label: str) -> None:
+  print(f"[{datetime.now().isoformat(timespec='seconds')}] {label}", file=sys.stderr)
+
+ phase("Detecting eras (multi-signal weighted-vote)...")
+ candidates: list[tuple[date, str, str]] = _gather_era_candidates()
+ eras: list[EraBoundary] = cluster_era_candidates(candidates, window_days=args.era_window_days)
+ # Override names using position-based logic.
+ named: list[EraBoundary] = []
+ for i, era in enumerate(eras):
+  named.append(
+   EraBoundary(
+    index=era.index,
+    start=era.start,
+    end=era.end,
+    name=assign_era_name(i, len(eras)),
+    evidence=era.evidence,
+   )
+  )
+ eras = named
+ phase(f"Detected {len(eras)} eras.")
+
+ phase("Building track index...")
+ tracks: list[TrackRow] = build_track_index(eras)
+ phase(f"Indexed {len(tracks)} tracks.")
+
+ phase("Building sub-agent task index (Op Layer A)...")
+ subagent_ops: list[SubAgentTaskOp] = build_subagent_task_index(eras, tracks)
+ phase(f"Indexed {len(subagent_ops)} sub-agent tasks.")
+
+ phase("Building commit-prefix index (Op Layer B)...")
+ commit_ops: list[CommitPrefixOp] = build_commit_prefix_index(eras, tracks)
+ phase(f"Indexed {len(commit_ops)} work-prefix commits.")
+
+ phase("Building session index (Op Layer C)...")
+ sessions: list[SessionOp] = build_session_index(eras, subagent_ops)
+ phase(f"Indexed {len(sessions)} sessions.")
+
+ phase("Computing per-era statistics...")
+ era_stats: list[EraStats] = compute_era_stats(eras, tracks, subagent_ops, commit_ops, sessions)
+
+ # Build the JSON artifact.
+ track_less_ops: dict[str, object] = {
+  "subagent_tasks": [op for op in subagent_ops if op.in_track is None],
+  "commits": [op for op in commit_ops if op.in_track is None],
+ }
+ stats: dict[str, object] = {
+  "schema_version": "1",
+  "generated_at": datetime.now().isoformat(timespec="seconds"),
+  "metadata": {
+   "repo_head": subprocess.run(
+    ["git", "rev-parse", "HEAD"], capture_output=True, text=True, check=False
+   ).stdout.strip(),
+   "analysis_date": analysis_date.isoformat(),
+   "era_window_days": args.era_window_days,
+   "track_count": len(tracks),
+   "subagent_task_count": len(subagent_ops),
+   "commit_count": len(commit_ops),
+   "session_count": len(sessions),
+  },
+  "eras": [_era_to_dict(e) for e in eras],
+  "tracks": [_track_to_dict(t) for t in tracks],
+  "ops": {
+   "subagent_tasks": [_subagent_to_dict(op) for op in subagent_ops],
+   "commits": [_commit_to_dict(op) for op in commit_ops],
+   "sessions": [_session_to_dict(s) for s in sessions],
+  },
+  "era_stats": [
+   {
+    "era_index": s.era.index,
+    "track_count": s.track_count,
+    "track_duration_median": round(s.track_duration_median, 1),
+    "track_duration_p25": round(s.track_duration_p25, 1),
+    "track_duration_p75": round(s.track_duration_p75, 1),
+    "track_commits_median": round(s.track_commits_median, 1),
+    "track_files_median": round(s.track_files_median, 1),
+    "subagent_task_count": s.subagent_task_count,
+    "subagent_task_duration_median": round(s.subagent_task_duration_median, 1),
+    "commit_count": s.commit_count,
+    "commit_count_by_prefix": s.commit_count_by_prefix,
+    "session_count": s.session_count,
+    "session_duration_median": round(s.session_duration_median, 1),
+    "track_less_op_count": s.track_less_op_count,
+   }
+   for s in era_stats
+  ],
+  "track_less_ops": {
+   "subagent_tasks": [_subagent_to_dict(op) for op in track_less_ops["subagent_tasks"]],
+   "commits": [_commit_to_dict(op) for op in track_less_ops["commits"]],
+  },
+ }
+
+ artifact_dir.mkdir(parents=True, exist_ok=True)
+ json_path: Path = artifact_dir / f"meta_tooling_stats_{analysis_date.isoformat()}.json"
+ with json_path.open("w", encoding="utf-8") as f:
+  json.dump(stats, f, indent=2)
+ phase(f"Wrote {json_path}")
+
+ if args.json_only:
+  return 0
+
+ # Build the Markdown report.
+ output_dir.mkdir(parents=True, exist_ok=True)
+ md_parts: list[str] = [
+  render_methodology(args.era_window_days),
+  render_era_timeline(eras),
+  render_track_stats(eras, tracks),
+  render_op_stats(commit_ops),
+  render_subagent_stats(subagent_ops),
+  render_trackless_ops(subagent_ops, commit_ops),
+  render_trends(commit_ops, subagent_ops),
+  render_use_case_predictions(tracks),
+  render_limitations(),
+  render_appendix(json_path),
+ ]
+ md_path: Path = output_dir / f"META_TOOLING_DURATION_ANALYSIS_{analysis_date.isoformat()}.md"
+ md_path.write_text("\n".join(md_parts), encoding="utf-8")
+ phase(f"Wrote {md_path}")
+
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
+```
+
+- [ ] **Step 8.2: Run --help to verify CLI is wired correctly**
+
+Run: `uv run python scripts/audit/analyze_meta_tooling_durations.py --help`
+Expected: prints help text. Exit code 0.
+
+- [ ] **Step 8.3: Commit**
+
+```bash
+git add scripts/audit/analyze_meta_tooling_durations.py
+git commit -m "feat(audit): writer (CLI main + JSON serialization + artifact emit)"
+```
+
+### Task 9: Integration run + verification
+
+**Files:**
+- Create: `docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md` (artifact)
+- Create: `tests/artifacts/meta_tooling_stats_2026-07-05.json` (artifact)
+
+- [ ] **Step 9.1: Run the full analyzer end-to-end**
+
+Run: `uv run python scripts/audit/analyze_meta_tooling_durations.py 2> tests/artifacts/_analyzer_stderr.log`
+Expected: Exit code 0. Stderr log shows the 8 phase lines. The 2 artifact files exist.
+
+- [ ] **Step 9.2: Verify the Markdown report has all 10 sections**
+
+Run:
+
+```bash
+$report = "docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md"
+$report_content = Get-Content $report -Raw
+for ($i = 1; $i -le 10; $i++) {
+  if ($report_content -notmatch "##\s+$i\.\s") {
+    Write-Error "Missing section $i in $report"
+    exit 1
+  }
+}
+Write-Host "All 10 sections present in $report"
+```
+
+Expected: `All 10 sections present in docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md`
+
+- [ ] **Step 9.3: Verify the JSON artifact has all top-level keys**
+
+Run:
+
+```bash
+$json_path = "tests/artifacts/meta_tooling_stats_2026-07-05.json"
+$stats = Get-Content $json_path -Raw | ConvertFrom-Json
+$required = @("schema_version", "generated_at", "metadata", "eras", "tracks", "ops", "era_stats", "track_less_ops")
+foreach ($key in $required) {
+  if (-not $stats.PSObject.Properties.Name -contains $key) {
+    Write-Error "Missing top-level key '$key' in $json_path"
+    exit 1
+  }
+}
+Write-Host "All $($required.Count) top-level keys present in $json_path"
+```
+
+Expected: `All 8 top-level keys present in tests/artifacts/meta_tooling_stats_2026-07-05.json`
+
+- [ ] **Step 9.4: Verify the Markdown report is 300+ lines**
+
+Run:
+
+```bash
+$report = "docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md"
+$line_count = (Get-Content $report).Count
+if ($line_count -lt 300) {
+  Write-Error "Report is only $line_count lines; expected 300+"
+  exit 1
+}
+Write-Host "Report is $line_count lines."
+```
+
+Expected: `Report is XXX lines.` (XXX >= 300).
+
+- [ ] **Step 9.5: Verify unit test coverage**
+
+Run: `uv run pytest tests/test_analyze_meta_tooling_durations.py --cov=scripts.audit.analyze_meta_tooling_durations --cov-report=term-missing`
+Expected: PASS, coverage >= 80% on pure-function modules (`cluster_era_candidates`, `assign_era_for_date`, `parse_subagent_task_log`, `parse_session_name`, `compute_era_stats`, the 10 `render_*` functions).
+
+- [ ] **Step 9.6: Verify script runtime is under 120s**
+
+Run: `Measure-Command { uv run python scripts/audit/analyze_meta_tooling_durations.py --json-only 2> $null | Out-Null }`
+Expected: TotalSeconds < 120.
+
+- [ ] **Step 9.7: Commit the artifacts**
+
+```bash
+git add docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md tests/artifacts/meta_tooling_stats_2026-07-05.json tests/artifacts/_analyzer_stderr.log
+git commit -m "feat(audit): generate META_TOOLING_DURATION_ANALYSIS_2026-07-05.md + JSON artifact"
+```
+
+### Task 10: Add chronology row + archive track
+
+**Files:**
+- Modify: `conductor/chronology.md` (add 1 row at top)
+- Move: `conductor/tracks/meta_tooling_duration_analysis_20260705/` → `conductor/archive/meta_tooling_duration_analysis_20260705/`
+
+- [ ] **Step 10.1: Add chronology row**
+
+Prepend a row to `conductor/chronology.md`:
+
+```markdown
+| 2026-07-05 | `meta_tooling_duration_analysis_20260705` | Completed | Empirical duration analysis of the meta-tooling that built this codebase from Feb 21 - Jul 5, 2026 (244 tracks; 1,005 sub-agent task logs; 317 session logs). Era-detection via multi-signal weighted-vote. 10-section Markdown report + JSON source-of-truth. No Application-domain changes. | `conductor/archive/meta_tooling_duration_analysis_20260705` | `<HEAD_AFTER_TASK_9_COMMIT>..<HEAD_AFTER_TASK_9_COMMIT>` (1) |
+```
+
+Use the actual SHAs from the previous commits.
+
+- [ ] **Step 10.2: Archive the track folder**
+
+```bash
+git mv conductor/tracks/meta_tooling_duration_analysis_20260705 conductor/archive/meta_tooling_duration_analysis_20260705
+```
+
+- [ ] **Step 10.3: Commit**
+
+```bash
+git add conductor/chronology.md conductor/archive/meta_tooling_duration_analysis_20260705
+git commit -m "docs(chronology): add row for meta_tooling_duration_analysis_20260705 archive"
+```
+
+---
+
+## Self-Review
+
+### Spec coverage
+
+| Spec section | Task(s) |
+|---|---|
+| Overview | All (track-wide) |
+| Current State Audit (reuse generate_chronology) | Task 2 (Step 2.3) |
+| Goals (5) | Distributed across all tasks |
+| Non-Goals (8) | Out of scope by design; nothing to implement |
+| Architecture (8 sections) | Tasks 1-8 (1:1) |
+| Per-File Design (3 files) | Tasks 1-8 |
+| FR1 (default invocation) | Task 9 Step 9.1 |
+| FR2 (--help) | Task 2 Step 2.7 |
+| FR3 (--json-only) | Task 8 Step 8.1 + Task 9 Step 9.6 |
+| FR4 (--output-dir) | Task 8 Step 8.1 |
+| FR5 (era evidence chain) | Task 8 `_gather_era_candidates` + render_era_timeline |
+| FR6 (JSON schema) | Task 8 Step 8.1 + Verification 9.3 |
+| FR7 (per-era stats) | Task 6 + render_track_stats |
+| FR8 (use-case predictions) | Task 7 render_use_case_predictions |
+| FR9 (deterministic) | All dataclasses are frozen; sort is stable |
+| FR10 (malformed log handling) | Task 3 Step 3.3 (returns None on parse failure) |
+| NFR1 (<120s runtime) | Task 9 Step 9.6 |
+| NFR2 (<500MB memory) | Implicit; dataclass-heavy |
+| NFR3 (no external tools) | All renderers use plain Markdown tables |
+| NFR4 (Limitations section) | Task 7 render_limitations |
+| NFR5 (progress to stderr) | Task 8 `phase()` helper |
+| NFR6 (>=80% test coverage) | Task 9 Step 9.5 |
+| Risks (R1-R4) | Addressed in CLI flags + render output |
+| Verification (V1-V7) | Task 9 Steps 9.1-9.6 |
+
+**No gaps found.**
+
+### Placeholder scan
+
+- No "TBD" / "TODO" / "implement later" in the plan.
+- All code blocks are complete (not "similar to Task N").
+- All file paths are exact.
+- All commands include expected output.
+
+### Type consistency
+
+- `EraBoundary.evidence: list[Evidence]` — used consistently in `cluster_era_candidates` (constructs Evidence) and `render_era_timeline` (iterates).
+- `TrackRow` — used in `build_track_index` (constructs), `compute_era_stats` (filters), `render_track_stats` (filters), `render_use_case_predictions` (filters). Field names match across all uses.
+- `SubAgentTaskOp.duration_s: float` — used in `compute_era_stats` and `_subagent_to_dict`. Consistent.
+- `CommitPrefixOp.prefix` — values `feat|fix|refactor|perf|test` checked in `_WORK_PREFIX_RE` and used as `Counter` keys.
+- `_percentile` and `_safe_median` — same signatures, used consistently.
+
+**No type inconsistencies found.**
\ No newline at end of file
diff --git a/conductor/archive/meta_tooling_duration_analysis_20260705/spec.md b/conductor/archive/meta_tooling_duration_analysis_20260705/spec.md
new file mode 100644
index 00000000..e5e2d602
--- /dev/null
+++ b/conductor/archive/meta_tooling_duration_analysis_20260705/spec.md
@@ -0,0 +1,237 @@
+# Track: Meta-Tooling Duration Analysis
+
+**Status:** Spec drafted 2026-07-05; awaiting user review
+**Initialized:** 2026-07-05
+**Owner:** Tier 1 Orchestrator (sole author of spec; Tier 2 Tech Lead executes the audit script per plan)
+**Priority:** Informational (one-shot analysis; no app behavior change)
+
+---
+
+## Overview
+
+Produce an empirical duration analysis of the meta-tooling that built this codebase from Feb 21 → Jul 5, 2026 (~133 days; 244 tracks; 1,946 track-folder commits; 1,005 sub-agent task logs; 317 session logs; 1,719 work-prefix commits globally).
+
+The deliverable is a **read-only analysis** in the Meta-Tooling domain (per `docs/guide_meta_boundary.md §0`): an audit script that consumes git history + on-disk log files and emits a Markdown report + JSON source-of-truth. **No Application-domain changes.** No `src/`, no `gui_2.py`, no MMA engine, no GUI panel.
+
+The user has ~3-6 months of LLM-assisted dev history and wants hard numbers to set realistic expectations for future tracks. The fundamental question: **"Given a future track with N files to modify and M scope, how long should I expect it to take, accounting for the era (model quality) it's happening in?"**
+
+## Current State Audit (as of `4c9fc99c`)
+
+### Already Exists (DO NOT re-implement; build on these)
+
+1. **`scripts/audit/generate_chronology.py:329-411`** — already extracts per-track `init_sha`, `end_sha`, `commit_count`, `date`, `folder_link` by walking `conductor/tracks/` + `conductor/archive/`. **Build on this**: import `_count_work_commits`, `_git_log`, `walk_track_folders`, `_repo_root` from this module instead of duplicating the git plumbing.
+2. **`conductor/chronology.md`** (248 lines, 244 rows, regenerated by `generate_chronology.py`) — the canonical per-track index. The new analyzer consumes this rather than re-walking the filesystem.
+3. **`docs/reports/`** directory — established convention for analysis output. Existing reports include `TRACK_COMPLETION_*`, `TRACK_ABORTED_*`, `PLANNING_DIGEST_*`, `SESSION_REPORT_*`. The new report joins this set as `META_TOOLING_DURATION_ANALYSIS_<date>.md`.
+4. **`logs/agents/mma_tier3-worker_task_*.log`, `mma_tier4-qa_task_*.log`, `mma_tier1_task_*.log`** — 1,005 sub-agent task logs with parseable `TIMESTAMP:` + `ROLE:` + `RESULT:` blocks. Established format per `scripts/audit/generate_chronology.py:43-58` which already references these.
+5. **`logs/<session>/`** directories (317 of them) — the higher-level chat session containers; each session wraps multiple sub-agent tasks. The session name pattern is `YYYYMMDD_HHMMSS[_<suffix>]` per the existing naming.
+6. **`config.toml`** — the runtime configuration. Its git history is the strongest single signal for era boundaries (provider/model line changes).
+7. **`conductor/workflow.md §0` and §"Conductor Token Firewalling"** — the canonical tier-model assignments (Tier 1 = `gemini-3.1-pro-preview`, Tier 2 = `gemini-3-flash-preview`, Tier 3/4 = `gemini-2.5-flash-lite`). This is the model-assumption baseline.
+
+### Gaps to Fill (this track's scope)
+
+- An era-detection algorithm using multi-signal weighted-vote (config.toml + workflow.md + track-spec content + agent-log content). No single source is authoritative.
+- A per-track duration model (init_sha → end_sha in calendar days, in work-commits, in files-touched).
+- A per-op duration model across 3 op layers:
+  - **Op Layer A: Sub-agent task logs** (`logs/agents/mma_tier*_task_*.log`) — parsed per-task duration (prompt received → result returned)
+  - **Op Layer B: Work-prefix commits** (`feat|fix|refactor|perf|test`) cross-cut by commit-prefix family
+  - **Op Layer C: Session logs** (`logs/<session>/`) — the top-level chat session durations
+- Track-attribution: which sub-agent tasks / commits land inside a known track folder vs which are "simple todos" (no track context).
+- Era-bucketed statistics: every metric broken down by detected era with the evidence chain.
+- A use-case prediction table: "for a track with N files in subsystem S, median duration is X" — derived from the per-track dataset.
+- The Markdown report (10 sections, ~300-500 lines) and JSON source-of-truth artifact.
+
+## Goals
+
+1. **Empirical, reproducible numbers.** Every duration in the report traces back to a specific JSON record; every era boundary traces back to a named git evidence chain.
+2. **Multi-dimensional slicing.** Track-level, op-level (3 layers), era-level — the same data sliced multiple ways so the user can answer different questions.
+3. **Self-documenting methodology.** §1 of the report explains exactly how eras were detected, what signals were weighted how, and what the failure modes are. Re-runs of the script (if any future agent runs it) produce the same output.
+4. **No app changes.** This is strictly Meta-Tooling analysis per `docs/guide_meta_boundary.md §0`. Zero edits to `src/`, `gui_2.py`, `ai_client.py`, the MMA engine, or the GUI.
+5. **Useful for expectation-setting.** §8 of the report has the use-case prediction table — the actual user-facing artifact for setting expectations.
+
+## Non-Goals
+
+- Not a re-runnable ongoing system. One-shot only (per user direction 2026-07-05).
+- Not a live dashboard. No GUI changes.
+- Not a predictive ML model. The use-case predictions are statistical aggregates (median + IQR), not a regression.
+- Not measuring LLM "thinking" time or token costs (those are not in the data we have).
+- Not measuring idle time between commits (we measure calendar days and work-commits, not active human/agent minutes).
+- Not tracking which specific model was used per commit (the per-task model is not logged; we can only era-bucket).
+- Not producing a CSV. JSON + Markdown only (per Q2 answer 2b).
+- Not regenerating `conductor/chronology.md`. We consume it; we don't rewrite it.
+
+## Architecture
+
+### Data Flow
+
+```
+git log (entire repo, 4,997 commits)
+   ↓
+git log -- config.toml (era detection)
+git log -- conductor/workflow.md (era detection)
+git log -- conductor/tracks/*/spec.md (era detection, model mentions)
+   ↓
+generate_chronology.py:walk_track_folders() (reused) → track index
+   ↓
+parse logs/agents/mma_tier*_task_*.log (Op Layer A) → task index
+   ↓
+git log --grep='^feat|^fix|^refactor|^perf|^test' (Op Layer B) → commit-prefix index
+   ↓
+parse logs/<session>/* (Op Layer C) → session index
+   ↓
+[era detector: multi-signal weighted-vote on date candidates]
+   ↓
+[track-attributor: bucket each op to a track or 'track-less']
+   ↓
+[statistician: per-track, per-op, per-era, per-use-case aggregations]
+   ↓
+[renderer: 10-section Markdown report]
+   ↓
+[writer: docs/reports/META_TOOLING_DURATION_ANALYSIS_<date>.md]
+[writer: tests/artifacts/meta_tooling_stats_<date>.json]
+```
+
+### Per-File Design
+
+#### NEW: `scripts/audit/analyze_meta_tooling_durations.py`
+
+A single-file audit script (~600-900 lines per `data_oriented_design.md §8.5` styleguide). Sections:
+
+1. **Era detection** (`detect_eras()` — pure function)
+   - Inputs: `Path` to repo root
+   - Signal A: `git log --diff-filter=AM -G "provider = " -- config.toml` → list of `(date, evidence)` candidates
+   - Signal B: `git log --diff-filter=AM -G "gemini-3|gemini-2\.5|MiniMax|claude|grok" -- conductor/workflow.md conductor/tech-stack.md` → list of `(date, evidence)`
+   - Signal C: `grep -l "model:" logs/agents/mma_tier3-worker_task_*.log` (per-file mtime + content model mentions) → first-appearance dates
+   - Signal D: `git log -G "gemini-3-flash-preview|gemini-3.1-pro-preview|MiniMax" -- conductor/tracks/*/spec.md` → per-track model mentions grouped by track init date
+   - Algorithm: cluster candidates within 7-day windows; cluster centroid becomes era boundary; record all evidence in the era's record
+   - Output: `list[EraBoundary]` dataclass instances
+
+2. **Track index** (`build_track_index()`)
+   - Imports `walk_track_folders`, `_git_log`, `_count_work_commits` from `scripts.audit.generate_chronology`
+   - Extends each row with: `init_date` (ISO), `end_date` (ISO), `duration_days`, `files_touched` (`git log --name-only --pretty=format: | sort -u | wc -l` per track folder), `era` (assigned by EraBoundary lookup)
+
+3. **Op Layer A: sub-agent task index** (`build_subagent_task_index()`)
+   - Walks `logs/agents/mma_tier*_task_*.log` (1,005 files)
+   - Parses header: `TIMESTAMP:`, `ROLE:` (tier3-worker / tier4-qa / tier1), `RESULT:` block
+   - `in_track` attribution: if the task's timestamp falls inside any track's `[init_date, end_date]` window → that track; else `None` (track-less)
+   - Outputs: `list[SubAgentTaskOp]` dataclass
+
+4. **Op Layer B: commit-prefix index** (`build_commit_prefix_index()`)
+   - `git log --grep='^(feat|fix|refactor|perf|test)(|\([^)]+\)):' --pretty=format:'%h|%ad|%s' --date=short`
+   - Same in-track attribution
+   - Outputs: `list[CommitPrefixOp]`
+
+5. **Op Layer C: session log index** (`build_session_index()`)
+   - Walks `logs/` (excludes `logs/agents/`); 317 dirs
+   - Session start = earliest mtime of any file in `logs/<session>/`
+   - Session end = latest mtime
+   - Output: `list[SessionOp]`
+
+6. **Statistician** (`compute_stats(track_idx, op_idx_a, op_idx_b, op_idx_c, eras)`)
+   - Per-track: median/p25/p75 of duration_days, commits, files touched
+   - Per-op-layer-per-era: median/p25/p75 of duration
+   - Per-week: commit count, task count, session count (moving avg)
+   - Per-use-case: tracks grouped by `files_touched` bucket → median duration per bucket
+   - All results in typed `@dataclass(frozen=True, slots=True)` per `data_oriented_design.md §8.5`
+
+7. **Renderer** (10 functions, one per Markdown section)
+   - `render_methodology()`, `render_era_timeline()`, `render_track_stats()`, `render_op_stats()`, `render_subagent_stats()`, `render_trackless_ops()`, `render_trends()`, `render_use_case_predictions()`, `render_limitations()`, `render_appendix()`
+   - Each returns a `str`; concatenated into the final report
+
+8. **Writer** (`write_artifacts(report_md, stats_json, output_dir)`)
+   - Writes `docs/reports/META_TOOLING_DURATION_ANALYSIS_<YYYY-MM-DD>.md`
+   - Writes `tests/artifacts/meta_tooling_stats_<YYYY-MM-DD>.json`
+
+#### NEW: `tests/test_analyze_meta_tooling_durations.py`
+
+Unit tests for the pure-function modules (era detection, statistician, parsers). Skips the git-process-spawning functions via mocks. ~150 lines.
+
+#### NEW: `docs/reports/META_TOOLING_DURATION_ANALYSIS_<YYYY-MM-DD>.md`
+
+The report. ~300-500 lines, 10 sections per design.
+
+#### NEW: `tests/artifacts/meta_tooling_stats_<YYYY-MM-DD>.json`
+
+The raw data. Schema per design §Q2.
+
+### Convention Compliance
+
+- **Python Type Promotion Mandate** (`data_oriented_design.md §8.5`): every dataclass uses `@dataclass(frozen=True, slots=True)`. No `dict[str, Any]`. No `Any`. No `Optional[T]` returns (use `Result[T]` + `NIL_T` per `error_handling.md`).
+- **1-space indentation** per `conductor/code_styleguides/python.md §1`.
+- **CRLF line endings** per `conductor/workflow.md §"Code Style"`.
+- **ImGui scope discipline**: N/A (no GUI in this track).
+- **Audit Script Policy** (`conductor/workflow.md §"Audit Script Policy"`): the script has a `--help`, supports `--json` (JSON-only output mode for re-analysis), and exits 0 on success.
+- **No new `src/<thing>.py` file** (per `AGENTS.md §"File Size and Naming Convention"`).
+
+## Functional Requirements
+
+1. **FR1**: The script MUST be invokable as `uv run python scripts/audit/analyze_meta_tooling_durations.py` with no arguments and produce both artifacts.
+2. **FR2**: The script MUST have `--help` output that documents the data sources, era detection algorithm, and limitations.
+3. **FR3**: The script MUST support `--json-only` to emit only the JSON artifact (no Markdown), for downstream re-analysis.
+4. **FR4**: The script MUST accept `--output-dir <path>` to override the default `docs/reports/` + `tests/artifacts/` destinations (CI/headless use).
+5. **FR5**: Every era boundary in the report MUST cite the git evidence chain (commit SHA + the diff line that triggered the boundary).
+6. **FR6**: The JSON artifact MUST be schema-versioned (`schema_version: "1"`) and contain `eras`, `tracks`, `ops` (3 lists: `subagent_tasks`, `commits`, `sessions`), `track_less_ops`, `metadata` (run timestamp + repo HEAD).
+7. **FR7**: Per-era stats MUST include: track count, median duration_days, p25/p75 duration_days, median commits, median files_touched, op counts per layer.
+8. **FR8**: Use-case predictions (§8) MUST group tracks by `files_touched` buckets (1-5, 6-15, 16-30, 31+) and report median + IQR duration_days per bucket per era.
+9. **FR9**: The script MUST be deterministic — same input repo state produces same output (sorted, no timestamps in the analytical content).
+10. **FR10**: The script MUST handle the case where some sub-agent task logs are malformed (missing `RESULT:` block) without crashing — log a warning, skip the entry, continue.
+
+## Non-Functional Requirements
+
+- **NFR1**: Script runtime: <120 seconds on the current repo state (4,997 commits, 1,005 log files, 317 sessions).
+- **NFR2**: Script memory: <500MB peak.
+- **NFR3**: The Markdown report MUST be human-readable without external tools (no Mermaid, no external CSS).
+- **NFR4**: The Markdown report MUST contain a "Limitations" section enumerating what the analysis cannot tell the user (e.g., LLM "thinking" time, idle time, per-task model attribution).
+- **NFR5**: The script MUST emit progress to stderr (line-buffered) so the user sees what's being computed (no silent 60-second stall).
+- **NFR6**: Test coverage for the pure-function modules (era detection, statistician, parsers) MUST be ≥80% lines.
+
+## Architecture Reference
+
+- **Meta-Tooling vs Application domain distinction**: `docs/guide_meta_boundary.md §0` — confirms this is Meta-Tooling-only.
+- **Per-source-file code audit pattern**: `conductor/code_styleguides/data_oriented_design.md §8.5` (Python Type Promotion Mandate).
+- **Audit script convention**: `conductor/workflow.md §"Audit Script Policy"` — the audit + CI gate pair pattern.
+- **Reused analysis primitives**: `scripts/audit/generate_chronology.py:329-411` (per-track walker).
+- **Standard convention**: `conductor/code_styleguides/python.md §1` (1-space indent); `conductor/code_styleguides/error_handling.md` (Result[T] + NIL_T).
+
+## Out of Scope
+
+- **No app behavior change** — strictly Meta-Tooling.
+- **No new `src/<thing>.py` file** — `scripts/audit/` is the only new namespace.
+- **No re-runnability / CI integration** — one-shot; not a CI gate.
+- **No CSV output** — Markdown + JSON only.
+- **No predictive ML model** — statistical aggregates only.
+- **No per-task model attribution** — we era-bucket by git-history evidence, not per-task logs.
+- **No measurement of LLM "thinking" time or token costs** — data not present.
+- **No GUI panel or live dashboard**.
+
+## Risks
+
+| Risk | Likelihood | Impact | Mitigation |
+|---|---|---|---|
+| Era detection produces too many/few eras (over/under-clustering) | Medium | Medium | 7-day cluster window is tunable via `--era-window-days`; report §1 documents the chosen window. |
+| Sub-agent task log parsing breaks on malformed files | Medium | Low | FR10 + warning log. |
+| Script runtime exceeds 120s on large repos | Low | Low | NFR1 budget; profile with `--profile` flag if needed. |
+| Use-case predictions in §8 have too few samples per bucket per era (high variance) | Medium | Medium | §8 reports bucket sample sizes; warns when N < 5. |
+| The user disagrees with the era boundaries I detect | Medium | Low | §1 documents the algorithm + evidence; user can rerun with `--era-window-days` or `--override-eras <csv>`. |
+| Session log parsing is brittle (folder naming varies) | Medium | Low | Parse by `YYYYMMDD_HHMMSS[_<suffix>]` pattern; skip dirs that don't match. |
+
+## Verification
+
+1. **V1**: `uv run python scripts/audit/analyze_meta_tooling_durations.py --help` exits 0 with the documented help text.
+2. **V2**: `uv run python scripts/audit/analyze_meta_tooling_durations.py` exits 0, produces `docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md` (≥300 lines), and produces `tests/artifacts/meta_tooling_stats_2026-07-05.json`.
+3. **V3**: `uv run python scripts/audit/analyze_meta_tooling_durations.py --json-only` exits 0, produces only the JSON, and the JSON validates against the documented schema.
+4. **V4**: `uv run pytest tests/test_analyze_meta_tooling_durations.py` passes with ≥80% line coverage on the pure-function modules.
+5. **V5**: The Markdown report contains all 10 sections in the documented order.
+6. **V6**: The JSON artifact contains the documented top-level keys (`schema_version`, `generated_at`, `eras`, `tracks`, `ops`, `track_less_ops`, `metadata`).
+7. **V7**: Script runtime is <120s on the current repo state (timed via `Measure-Command`).
+
+## Definition of Done
+
+- [ ] All 7 verification criteria pass.
+- [ ] All 10 functional requirements implemented.
+- [ ] All 6 non-functional requirements met.
+- [ ] The audit script is committed to `scripts/audit/analyze_meta_tooling_durations.py`.
+- [ ] The unit tests are committed to `tests/test_analyze_meta_tooling_durations.py`.
+- [ ] The Markdown report is committed to `docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md`.
+- [ ] The JSON artifact is committed to `tests/artifacts/meta_tooling_stats_2026-07-05.json`.
+- [ ] A chronology.md row added: `docs(chronology): add row for meta_tooling_duration_analysis_20260705 archive` (when the track folder is archived after shipping).
+- [ ] This spec is reviewed and approved by the user before plan.md is written.
\ No newline at end of file
diff --git a/conductor/archive/meta_tooling_duration_analysis_20260705/state.toml b/conductor/archive/meta_tooling_duration_analysis_20260705/state.toml
new file mode 100644
index 00000000..d32d89ac
--- /dev/null
+++ b/conductor/archive/meta_tooling_duration_analysis_20260705/state.toml
@@ -0,0 +1,50 @@
+# Track state for meta_tooling_duration_analysis_20260705
+# Updated by Tier 2 Tech Lead as tasks complete
+
+[meta]
+track_id = "meta_tooling_duration_analysis_20260705"
+name = "Meta-Tooling Duration Analysis"
+status = "spec_pending_review"
+current_phase = 0
+last_updated = "2026-07-05"
+
+[blocked_by]
+# None
+
+[blocks]
+# None (informational track)
+
+[phases]
+phase_1 = { status = "pending", checkpointsha = "", name = "Era detection + multi-signal voting" }
+phase_2 = { status = "pending", checkpointsha = "", name = "Build track + op-layer indices (3 layers)" }
+phase_3 = { status = "pending", checkpointsha = "", name = "Statistician + 10-section renderer" }
+phase_4 = { status = "pending", checkpointsha = "", name = "Writer + unit tests + verification" }
+
+[tasks]
+# Phase 1
+t1_1 = { status = "pending", commit_sha = "", description = "Era detector: multi-signal weighted-vote algorithm" }
+# Phase 2
+t2_1 = { status = "pending", commit_sha = "", description = "Build track index (reuse generate_chronology walker; extend with dates/files)" }
+t2_2 = { status = "pending", commit_sha = "", description = "Build sub-agent task index (Op Layer A: logs/agents/mma_tier*_task_*.log)" }
+t2_3 = { status = "pending", commit_sha = "", description = "Build commit-prefix index (Op Layer B: feat|fix|refactor|perf|test)" }
+t2_4 = { status = "pending", commit_sha = "", description = "Build session index (Op Layer C: logs/<session>/)" }
+# Phase 3
+t3_1 = { status = "pending", commit_sha = "", description = "Statistician module: per-track, per-op, per-era, per-use-case aggregations" }
+t3_2 = { status = "pending", commit_sha = "", description = "Renderer: 10 Markdown section functions" }
+# Phase 4
+t4_1 = { status = "pending", commit_sha = "", description = "Writer: emit docs/reports/META_TOOLING_DURATION_ANALYSIS_2026-07-05.md + tests/artifacts/meta_tooling_stats_2026-07-05.json" }
+t4_2 = { status = "pending", commit_sha = "", description = "Unit tests for pure-function modules (80% line coverage target)" }
+t4_3 = { status = "pending", commit_sha = "", description = "Run full script + verify all 7 verification criteria + commit artifacts" }
+
+[verification]
+phase_1_complete = false
+phase_2_complete = false
+phase_3_complete = false
+phase_4_complete = false
+v1_help_exits_0 = false
+v2_default_invocation_produces_artifacts = false
+v3_json_only_mode = false
+v4_unit_tests_pass = false
+v5_markdown_has_10_sections = false
+v6_json_schema_complete = false
+v7_runtime_under_120s = false
\ No newline at end of file
diff --git a/conductor/chronology.md b/conductor/chronology.md
index ff4074c4..c4bc6437 100644
--- a/conductor/chronology.md
+++ b/conductor/chronology.md
@@ -2,6 +2,8 @@
 
 | Date | ID | Status | Summary | Folder | Range |
 | --- | --- | --- | --- | --- | --- |
+| 2026-07-05 | `test_suite_cleanup_gemini_cli_removal_20260705` | Active | 3-front cleanup: (A) remove the graveyarded Gemini CLI adapter from src/+tests/+docs + introduce a `mock` provider for the 9 sim tests; (B) downsize the test suite ~45-60 files (delete guaranteed-broken chronology tests, consolidate 7 scavenge tautologies, migrate 27 src.models shim importers, fix 3 fix-not-skip candidates, audit the 120KB test_gui_2_result.py); (C) reduce Metadata type usage beyond TOML boundaries (flip the 38-site MCP dispatch inversion, migrate app_controller.py's 40 in-memory Metadata sites to typed dataclasses, fix aggregate.py FileItem slippage). spec ✓, plan ✓, ready to start. | `conductor/tracks/test_suite_cleanup_gemini_cli_removal_20260705` | (not yet started) |
+| 2026-07-05 | `meta_tooling_duration_analysis_20260705` | Completed | One-shot empirical duration analysis of the meta-tooling that built this codebase Feb 21 - Jul 5, 2026 (133 days; 248 tracks; 1003 sub-agent tasks; 1608 work-prefix commits; 312 sessions). Era-detection via multi-signal weighted-vote (config.toml + workflow.md + tech-stack.md + agent-log content; 7-day cluster window). 5 eras detected. 10-section Markdown report + JSON source-of-truth. Tier 3 worker median task: 272.5s. No Application-domain changes. | `conductor/archive/meta_tooling_duration_analysis_20260705` | `127be22f..ce0d1438` (3) |
 | 2026-07-05 | `twitter_threads_extraction_20260705` | Active | Standalone Python scripts + workflow for extracting Twitter/X posts and threads into Markdown with associated media. Mirrors the `scripts/video_analysis/` pattern. spec ✓, plan ✓, ready to start. | `conductor/tracks/twitter_threads_extraction_20260705` | (not yet started) |
 | 2026-07-05 | `superpowers_review_apply_high_20260705` | Completed | Phase 1: `26dd9258` Session Start Checklist item 13 added; Phase 2: `670a919e` tests/test_mma_skill_discipline.py (25 cases); Phase 3: `5037f48f` cross-reference + finalization. | `conductor/archive/superpowers_review_apply_high_20260705` | `0522252f..5037f48f` (3) |
 | 2026-07-05 | `superpowers_review_20260619` | Completed | 16-section review of the superpowers skill suite: 14 PARITY / 3 PARTIAL / 2 ARCH-DIFF / 1 GAP; 25 decisions logged; 3 side artifacts (decisions.md, comparison_table.md, nagent_takeaways). | `conductor/archive/superpowers_review_20260619` | `eb272cb7..137868a1` (40) |
diff --git a/conductor/tracks.md b/conductor/tracks.md
index a4e098ad..ea75fabd 100644
--- a/conductor/tracks.md
+++ b/conductor/tracks.md
@@ -22,6 +22,7 @@ Tracks that are unblocked and ready to start. Ordered by **dependency** (blocked
 | 22b | A | [Meta-Tooling Workflow Review](#track-meta-tooling-workflow-review) | spec ✓, plan ✓, parked | (none) |
 | 23 | A | [Intent-Based Scripting Languages Survey](#track-intent-dsl-survey) | spec ✓, plan pending | (none) |
 | 30 | A | [Twitter/X Thread Extraction Tooling](#track-twitter-threads-extraction) | spec ✓, plan ✓, ready to start | (none) |
+| 31 | A | [Test Suite Cleanup + Gemini CLI Removal + Metadata Reduction](#track-test-suite-cleanup) | spec ✓, plan ✓, ready to start | (none) |
 | 7 | — | [UI Polish (Five Issues)](#track-ui-polish-five-issues) | spec ✓, plan ✓, ready to start | (none) |
 | 19 | — | [Context First Message Fix](#track-context-first-message-fix) | spec TBD | (none) |
 
@@ -32,6 +33,7 @@ Tracks that are unblocked and ready to start. Ordered by **dependency** (blocked
 - **Meta-Tooling Workflow Review** → `conductor/tracks/meta_tooling_workflow_review_20260620/`
 - **Intent-Based Scripting Languages Survey** → `conductor/tracks/intent_dsl_survey_20260612/`
 - **Twitter/X Thread Extraction Tooling** → `conductor/tracks/twitter_threads_extraction_20260705/`
+- **Test Suite Cleanup + Gemini CLI Removal + Metadata Reduction** → `conductor/tracks/test_suite_cleanup_gemini_cli_removal_20260705/`
 - **UI Polish (Five Issues)** → `conductor/tracks/` (see spec for details)
 - **Context First Message Fix** → `conductor/tracks/context_first_message_fix_20260604/`