prizmkit 1.1.68 → 1.1.70

package/bundled/dev-pipeline/templates/sections/task-contract.md

@@ -0,0 +1,34 @@
+## Task Contract
+
+This section defines the only work that belongs to this session.
+
+### Objective
+
+Implement {{FEATURE_ID}}: "{{FEATURE_TITLE}}".
+
+{{FEATURE_DESCRIPTION}}
+
+### Scope Rule
+
+Current scope is limited to the intersection of:
+
+1. The Objective above
+2. The Verification Gates below
+3. Dependencies required to complete those gates
+
+Raw user context, project brief, and completed dependency notes are authoritative context, but they do not expand scope by themselves.
+
+### Non-Scope Rule
+
+Do NOT implement unrelated backlog items, already completed features, or adjacent modules unless they are required by the Objective or a Verification Gate.
+
+### Verification Gates
+
+These gates are generated from `feature.acceptance_criteria` and are the only acceptance requirements for this session.
+
+{{AC_CHECKLIST}}
+
+Gate rule:
+- `[x]` means verified with implementation or test evidence.
+- Any remaining `[ ]` means the feature is incomplete.
+- If a gate is blocked, document the reason in `failure-log.md`; blocked is not success.

package/bundled/dev-pipeline/templates/sections/test-failure-recovery-agent.md

@@ -1,67 +1,48 @@
 ## Test Failure Recovery Protocol
 
-When tests fail during implementation (Phase 3 / Phase 4), use **convergence-based recovery** — keep fixing as long as progress is being made.
+Use this protocol whenever implementation or review tests fail. Its purpose is to distinguish tolerated pre-existing failures from blockers introduced by this session.
 
-### Recovery Loop
-
-1. **Run tests and record results**:
-   - Count total failures and note which tests failed
-   - Compare against baseline (BASELINE_FAILURES) — exclude pre-existing failures
-
-2. **Check termination conditions** (evaluate BEFORE each fix attempt):
-   - **All tests pass** → Done. Exit recovery loop.
-   - **Plateau detected** — same failure count AND same failing tests for 3 consecutive rounds → AI cannot resolve these failures. Document and exit.
-   - **Still making progress** — failure count decreased compared to previous round → Continue fixing.
-   - **First round** — no history yet → Proceed to fix.
-
-3. **Fix and iterate**:
-   - Analyze remaining failures: root cause (code bug vs. test brittleness vs. environment issue)
-   - Categorize:
-     - **Pre-existing baseline failure**: Expected, do NOT fix
-     - **New regression**: Fix the code
-     - **Brittle test**: Fix the test or environment setup
-   - Apply fix, re-run `($TEST_CMD)`, go back to step 1
+### Failure Classes
 
-### Convergence Tracking
+| Class | Meaning | Required Action | May Continue? |
+|-------|---------|-----------------|---------------|
+| Baseline failure | Existed before this session | Document in Implementation Log or review notes | Yes |
+| New regression | Introduced by this session | Fix before reporting success | No |
+| Brittle test | Test expectation/setup is wrong for the intended behavior | Fix the test or environment setup, then rerun | Only after fixed or documented as blocked |
+| Environment/tooling failure | External tool, network, install, or local environment prevents verification | Document in `failure-log.md` with impact on gates | Only if no Verification Gate is blocked |
 
-Track failures each round. Example: 5→3→3→3→3 = plateau at round 3, stop at round 5 (3/3).
+### Recovery Loop
 
-**Key rule**: If failures decrease (even by 1), the plateau counter resets to 0.
+1. Run tests and record: failing test names, failure count, and class for each failure.
+2. Compare with `BASELINE_FAILURES`; never blame baseline failures on this feature.
+3. Fix new regressions and brittle tests while progress is being made.
+4. Stop after a plateau: same failure count and same failing tests for 3 consecutive rounds.
+5. If failures decrease, reset the plateau counter.
 
-### Escalation — Dev + Reviewer Workflow
+### Success Rule
 
-When the recovery loop exits with remaining failures:
-- Dev appends failure details to Implementation Log
-- Reviewer agent runs full test suite in Phase 5
-- If Reviewer confirms NEW regressions (not in baseline): mark verdict as `NEEDS_FIXES`
-- If Reviewer confirms only baseline failures remain: proceed with `PASS_WITH_WARNINGS`
+Proceed to review only when:
 
-### Context-Aware Test Re-run (Performance Optimization)
+1. all new regressions are fixed;
+2. baseline failures are documented;
+3. every Verification Gate is verified.
 
-**Skip redundant re-runs**:
-- If Implementation Log section in context-snapshot.md already confirms "all tests passing"
-- → Skip Phase 5 test suite re-run (Reviewer will verify baseline log instead)
-- This avoids rebuilding/re-running tests when already verified
+Blocked gates are not success. If any gate cannot be verified, follow the Blocked Rule.
 
-**When to re-run**:
-- If Implementation Log is missing or incomplete
-- If any new code was added after the last test run
-- If Reviewer suspects brittleness or environment drift
+### Blocked Rule
 
-### Failure Capture Rules
+If a remaining failure prevents any Verification Gate from being verified, the feature is incomplete. Write `failure-log.md` and do not report success.
 
-If tests remain broken after recovery:
+### Failure Capture Format
 
-```
+```markdown
 ## Test Failures Encountered
 
 - **Test**: [test name/path]
   - Root Cause: [explanation]
-  - Category: [pre-existing baseline | new regression | brittle test | environment]
+  - Category: [baseline failure | new regression | brittle test | environment/tooling]
   - Rounds Attempted: [N rounds, plateau at round M]
-  - Status: [still failing | requires next session | known limitation]
+  - Status: [fixed | still failing | blocked]
 
-- **Impact on Feature**: [can AC be verified despite failure | blocks AC verification]
+- **Impact on Verification Gates**: [verified | not affected | blocked + reason]
 ```
-
-**Rule**: If any AC cannot be verified due to test failure, the feature is incomplete. Document in failure-log.md for next session.

package/bundled/dev-pipeline/templates/sections/test-failure-recovery-lite.md

@@ -1,58 +1,48 @@
 ## Test Failure Recovery Protocol
 
-When tests fail during implementation, use **convergence-based recovery** — keep fixing as long as progress is being made.
+Use this protocol whenever implementation tests fail. Its purpose is to distinguish tolerated pre-existing failures from blockers introduced by this session.
 
-### Recovery Loop
-
-1. **Run tests and record results**:
-   - Count total failures and note which tests failed
-   - Compare against baseline (BASELINE_FAILURES) — exclude pre-existing failures
-
-2. **Check termination conditions** (evaluate BEFORE each fix attempt):
-   - **All tests pass** → Done. Exit recovery loop.
-   - **Plateau detected** — same failure count AND same failing tests for 3 consecutive rounds → AI cannot resolve these failures. Document and exit.
-   - **Still making progress** — failure count decreased compared to previous round → Continue fixing.
-   - **First round** — no history yet → Proceed to fix.
+### Failure Classes
 
-3. **Fix and iterate**:
-   - Analyze remaining failures: root cause (code bug vs. test brittleness vs. environment issue)
-   - Categorize:
-     - **Pre-existing baseline failure**: Expected, do NOT fix
-     - **New regression**: Fix the code
-     - **Brittle test**: Fix the test or environment setup
-   - Apply fix, re-run `($TEST_CMD)`, go back to step 1
+| Class | Meaning | Required Action | May Continue? |
+|-------|---------|-----------------|---------------|
+| Baseline failure | Existed before this session | Document in Implementation Log | Yes |
+| New regression | Introduced by this session | Fix before reporting success | No |
+| Brittle test | Test expectation/setup is wrong for the intended behavior | Fix the test or environment setup, then rerun | Only after fixed or documented as blocked |
+| Environment/tooling failure | External tool, network, install, or local environment prevents verification | Document in `failure-log.md` with impact on gates | Only if no Verification Gate is blocked |
 
-### Convergence Tracking
+### Recovery Loop
 
-Track failures each round. Example: 5→3→3→3→3 = plateau at round 3, stop at round 5 (3/3).
+1. Run tests and record: failing test names, failure count, and class for each failure.
+2. Compare with `BASELINE_FAILURES`; never blame baseline failures on this feature.
+3. Fix new regressions and brittle tests while progress is being made.
+4. Stop after a plateau: same failure count and same failing tests for 3 consecutive rounds.
+5. If failures decrease, reset the plateau counter.
 
-**Key rule**: If failures decrease (even by 1), the plateau counter resets to 0.
+### Success Rule
 
-### Escalation — Single Agent
+Proceed only when:
 
-When the recovery loop exits with remaining failures:
-- Document all remaining failures in Implementation Log with root cause analysis
-- Record PARTIAL status with known failure list
-- **Do NOT block commit** — unresolved test failures are deferred to next session
+1. all new regressions are fixed;
+2. baseline failures are documented;
+3. every Verification Gate is verified.
 
-### Context-Aware Optimization
+Blocked gates are not success. If any gate cannot be verified, follow the Blocked Rule.
 
-**Skip redundant re-runs**: If Implementation Log already confirms "all tests passing", skip full suite re-run.
+### Blocked Rule
 
-### Failure Capture Rules
+If a remaining failure prevents any Verification Gate from being verified, the feature is incomplete. Write `failure-log.md` and do not report success.
 
-If tests remain broken after recovery:
+### Failure Capture Format
 
-```
+```markdown
 ## Test Failures Encountered
 
 - **Test**: [test name/path]
   - Root Cause: [explanation]
-  - Category: [pre-existing baseline | new regression | brittle test | environment]
+  - Category: [baseline failure | new regression | brittle test | environment/tooling]
   - Rounds Attempted: [N rounds, plateau at round M]
-  - Status: [still failing | requires next session | known limitation]
+  - Status: [fixed | still failing | blocked]
 
-- **Impact on Feature**: [can AC be verified despite failure | blocks AC verification]
+- **Impact on Verification Gates**: [verified | not affected | blocked + reason]
 ```
-
-**Rule**: If any AC cannot be verified due to test failure, the feature is incomplete. Document in failure-log.md for next session.

package/bundled/dev-pipeline/tests/test_generate_bootstrap_prompt.py

@@ -6,6 +6,7 @@ from generate_bootstrap_prompt import (
     compute_feature_slug,
     find_feature,
     format_acceptance_criteria,
+    format_ac_checklist,
     format_global_context,
     get_completed_dependencies,
     determine_pipeline_mode,
@@ -73,6 +74,18 @@ class TestFormatAcceptanceCriteria:
         assert "- Password reset works" in result
 
 
+class TestFormatAcChecklist:
+    def test_empty_does_not_create_unchecked_gate(self):
+        result = format_ac_checklist([])
+        assert result == "- (no Verification Gates specified)"
+        assert "[ ]" not in result
+
+    def test_items_are_unchecked_verification_gates(self):
+        result = format_ac_checklist(["Users can log in", "Password reset works"])
+        assert "- [ ] Users can log in" in result
+        assert "- [ ] Password reset works" in result
+
+
 # ---------------------------------------------------------------------------
 # format_global_context
 # ---------------------------------------------------------------------------

package/bundled/dev-pipeline-windows/scripts/generate-bootstrap-prompt.py

@@ -286,7 +286,7 @@ def extract_baseline_failures(test_commands, project_root):
 def format_ac_checklist(acceptance_criteria):
     """Format acceptance criteria as a markdown checkbox list."""
     if not acceptance_criteria:
-        return "- [ ] (no acceptance criteria specified)"
+        return "- (no Verification Gates specified)"
     lines = []
     for item in acceptance_criteria:
         lines.append("- [ ] {}".format(item))
@@ -323,10 +323,10 @@ def format_user_context(user_context):
     if not items:
         return ""
     lines = [
-        "### User-Provided Context (HIGHEST PRIORITY)",
-        "",
-        "> The following materials were provided by the user. "
-        "They take precedence over AI inference.",
+        "> These materials were provided by the user and are authoritative "
+        "when they clarify or constrain this feature. They do not expand "
+        "the current scope by themselves; use the Task Contract to decide "
+        "what belongs to this session.",
         "",
     ]
     for item in items:
@@ -970,6 +970,10 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
     mission += "\n\n" + tier_desc
     sections.append(("mission", mission))
 
+    # --- Task Contract: single source of current scope and gates ---
+    sections.append(("task-contract",
+                      load_section(sections_dir, "task-contract.md")))
+
     # --- Feature Context (XML-wrapped, optimization 3) ---
     sections.append(("feature-context",
                       load_section(sections_dir, "feature-context.md")))
@@ -1079,13 +1083,8 @@ def assemble_sections(pipeline_mode, sections_dir, init_done, is_resume,
                           load_section(sections_dir,
                                        "test-failure-recovery-agent.md")))
 
-    # --- AC Verification Checklist (all tiers) ---
-    ac_checklist_path = os.path.join(sections_dir, "ac-verification-checklist.md")
-    if os.path.isfile(ac_checklist_path):
-        sections.append(("ac-verification-checklist",
-                          load_section(sections_dir,
-                                       "ac-verification-checklist.md")))
-
+    # Verification Gates are included in Task Contract. Keep AC in one place so
+    # background context and implementation prompts cannot redefine scope.
     # --- Review (only for agent tiers) ---
     if pipeline_mode == "full":
         sections.append(("phase-review",

package/bundled/dev-pipeline-windows/scripts/parse-stream-progress.py

@@ -63,7 +63,8 @@ PHASE_KEYWORDS = {
 class ProgressTracker:
     """Tracks progress state from stream-json events."""
 
-    def __init__(self):
+    def __init__(self, session_log=None):
+        self.session_log_path = Path(session_log).expanduser() if session_log else None
         self.message_count = 0
         self.current_tool = None
         self.current_tool_input_summary = ""
@@ -78,12 +79,19 @@ class ProgressTracker:
         self.active_subagent_count = 0
         self.subagent_status_counts = Counter()
         self.codex_child_thread_ids = set()
+        self.claude_session_id = ""
+        self.claude_cwd = ""
+        self.claude_task_states = {}
         self.child_session_files = []
         self.child_total_bytes = 0
         self.child_activity_signature = ""
         self.last_child_activity_at = ""
         self._codex_child_session_paths = {}
+        self._claude_child_session_files = []
         self._last_child_scan_at = 0.0
+        self._last_claude_fallback_scan_at = 0.0
+        self._last_claude_fallback_scan_key = ""
+        self._claude_fallback_scan_interval_seconds = 10.0
         self._text_buffer = ""
         self._in_tool_use = False
         self._current_tool_input_parts = []
@@ -195,11 +203,76 @@ class ProgressTracker:
             self.is_active = True
 
         elif event_type == "system":
-            # System events (hooks, init, etc.) — track but don't count as messages
+            # System events (hooks, init, task notifications, etc.) — track but don't count as messages.
             self.event_format = self.event_format or "stream-json"
             subtype = event.get("subtype", "")
             if subtype == "init":
                 self.is_active = True
+                session_id = event.get("session_id")
+                if isinstance(session_id, str) and session_id.strip():
+                    self.claude_session_id = session_id.strip()
+                cwd = event.get("cwd")
+                if isinstance(cwd, str) and cwd.strip():
+                    self.claude_cwd = cwd.strip()
+            elif subtype == "task_started":
+                task_id = event.get("task_id")
+                if isinstance(task_id, str) and task_id.strip():
+                    self.claude_task_states[task_id.strip()] = {
+                        "status": "running",
+                        "summary": str(event.get("description") or "")[:120],
+                        "tool_use_id": str(event.get("tool_use_id") or ""),
+                        "task_type": str(event.get("task_type") or ""),
+                        "subagent_type": str(event.get("subagent_type") or ""),
+                    }
+                    self._update_claude_subagent_status_counts()
+            elif subtype in ("task_updated", "task_progress"):
+                task_id = event.get("task_id")
+                if isinstance(task_id, str) and task_id.strip():
+                    state = self.claude_task_states.setdefault(task_id.strip(), {})
+                    patch = event.get("patch") if isinstance(event.get("patch"), dict) else {}
+                    status = patch.get("status") or event.get("status")
+                    if status:
+                        state["status"] = str(status)
+                    summary = patch.get("summary") or patch.get("description") or event.get("summary") or event.get("description")
+                    if summary:
+                        state["summary"] = str(summary)[:120]
+                    else:
+                        state.setdefault("summary", "")
+                    tool_use_id = patch.get("tool_use_id") or event.get("tool_use_id")
+                    if tool_use_id:
+                        state["tool_use_id"] = str(tool_use_id)
+                    else:
+                        state.setdefault("tool_use_id", "")
+                    task_type = patch.get("task_type") or event.get("task_type")
+                    if task_type:
+                        state["task_type"] = str(task_type)
+                    else:
+                        state.setdefault("task_type", "")
+                    subagent_type = patch.get("subagent_type") or event.get("subagent_type")
+                    if subagent_type:
+                        state["subagent_type"] = str(subagent_type)
+                    else:
+                        state.setdefault("subagent_type", "")
+                    self._update_claude_subagent_status_counts()
+            elif subtype == "task_notification":
+                task_id = event.get("task_id")
+                if isinstance(task_id, str) and task_id.strip():
+                    state = self.claude_task_states.setdefault(task_id.strip(), {})
+                    status = event.get("status") or "completed"
+                    state["status"] = str(status)
+                    state["summary"] = str(event.get("summary") or state.get("summary") or "")[:120]
+                    state.setdefault("tool_use_id", str(event.get("tool_use_id") or ""))
+                    task_type = event.get("task_type")
+                    if task_type:
+                        state["task_type"] = str(task_type)
+                    else:
+                        state.setdefault("task_type", "")
+                    subagent_type = event.get("subagent_type")
+                    if subagent_type:
+                        state["subagent_type"] = str(subagent_type)
+                    else:
+                        state.setdefault("subagent_type", "")
+                    self._update_claude_subagent_status_counts()
 
         # ── Claude API raw stream format ────────────────────────────
         elif event_type == "message_start":
@@ -391,16 +464,135 @@ class ProgressTracker:
             pass
         return str(matches[0])
 
+    def _is_tracked_claude_subagent_state(self, state):
+        """Return true for Claude Code task events representing in-process agents."""
+        if not isinstance(state, dict):
+            return False
+        task_type = str(state.get("task_type") or "")
+        task_type_lower = task_type.lower()
+        subagent_type = str(state.get("subagent_type") or "")
+        if task_type_lower == "local_bash":
+            return False
+        tracked_types = {"in_process_teammate", "subagent", "agent", "teammate"}
+        if task_type_lower in tracked_types:
+            return True
+        if task_type_lower == "local_agent" and subagent_type:
+            return True
+        summary = str(state.get("summary") or "")
+        return bool(
+            not task_type
+            and summary.lower().startswith(("dev:", "critic:", "reviewer:", "agent:"))
+        )
+
+    def _has_tracked_claude_subagent_task(self):
+        """Return true once a Claude Code local-agent/subagent task has been observed."""
+        return any(
+            self._is_tracked_claude_subagent_state(state)
+            for state in self.claude_task_states.values()
+        )
+
+    def _update_claude_subagent_status_counts(self):
+        """Track Claude Code in-process teammate task state counts."""
+        counts = Counter()
+        active = 0
+        inactive_statuses = {
+            "completed",
+            "failed",
+            "cancelled",
+            "canceled",
+            "killed",
+            "stopped",
+            "success",
+            "error",
+        }
+        for state in self.claude_task_states.values():
+            if not self._is_tracked_claude_subagent_state(state):
+                continue
+            status = str(state.get("status") or "unknown")
+            counts[status] += 1
+            if status.lower() not in inactive_statuses:
+                active += 1
+            summary = state.get("summary") or state.get("subagent_type")
+            if summary:
+                self.last_text_snippet = str(summary).strip()[:120]
+                self._detect_phase(str(summary))
+        self.subagent_status_counts = counts
+        self.active_subagent_count = active
+
+    def _claude_projects_dir(self):
+        """Return the Claude Code projects directory for transcript lookup."""
+        projects_dir = os.environ.get("CLAUDE_PROJECTS_DIR")
+        if projects_dir:
+            return Path(projects_dir).expanduser()
+        claude_config_dir = os.environ.get("CLAUDE_CONFIG_DIR")
+        if claude_config_dir:
+            return Path(claude_config_dir).expanduser() / "projects"
+        claude_home = os.environ.get("CLAUDE_HOME")
+        if claude_home:
+            return Path(claude_home).expanduser() / "projects"
+        return Path.home() / ".claude" / "projects"
+
+    def _claude_project_key(self):
+        """Encode cwd the same way Claude Code stores project transcript dirs."""
+        cwd = self.claude_cwd
+        if not cwd:
+            return ""
+        return cwd.replace("\\", "-").replace("/", "-").replace(":", "")
+
+    def _find_claude_child_session_files(self):
+        """Find Claude Code subagent transcripts for this parent session."""
+        if not self.claude_session_id:
+            return []
+
+        projects_dir = self._claude_projects_dir()
+        if not projects_dir.exists():
+            return []
+
+        candidates = []
+        project_key = self._claude_project_key()
+        if project_key:
+            candidates.append(
+                projects_dir / project_key / self.claude_session_id / "subagents"
+            )
+
+        for candidate in candidates:
+            if candidate.exists():
+                try:
+                    return sorted(candidate.glob("*.jsonl"))
+                except OSError:
+                    return []
+
+        # Fallback for non-standard cwd encoding or custom Claude homes. Avoid
+        # repeatedly walking every stored transcript before any Agent task exists.
+        if not self._has_tracked_claude_subagent_task():
+            return []
+
+        fallback_scan_key = f"{projects_dir}:{self.claude_session_id}"
+        now = time.monotonic()
+        if (
+            self._last_claude_fallback_scan_key == fallback_scan_key
+            and now - self._last_claude_fallback_scan_at < self._claude_fallback_scan_interval_seconds
+        ):
+            return self._claude_child_session_files
+        self._last_claude_fallback_scan_key = fallback_scan_key
+        self._last_claude_fallback_scan_at = now
+        try:
+            matches = sorted(projects_dir.rglob(f"{self.claude_session_id}/subagents/*.jsonl"))
+        except OSError:
+            return []
+        return matches
+
     def refresh_child_session_activity(self, force=False):
-        """Refresh Codex child transcript file stats.
+        """Refresh child transcript file stats.
 
         The heartbeat monitor uses this activity signature to treat subagent
-        transcript growth as real progress while the parent Codex session is
-        blocked in `wait`.
+        transcript growth as real progress while the parent session is blocked
+        waiting for a child agent/tool result. Supports Codex child threads and
+        Claude Code in-process teammate transcripts.
         """
         previous_signature = self.child_activity_signature
 
-        if not self.codex_child_thread_ids:
+        if not self.codex_child_thread_ids and not self.claude_session_id:
             self.child_session_files = []
             self.child_total_bytes = 0
             self.child_activity_signature = ""
@@ -420,6 +612,7 @@ class ProgressTracker:
                     found = self._find_codex_child_session_file(thread_id)
                     if found:
                         self._codex_child_session_paths[thread_id] = found
+            self._claude_child_session_files = self._find_claude_child_session_files()
             self._last_child_scan_at = now
 
         files = []
@@ -427,24 +620,22 @@ class ProgressTracker:
         total_bytes = 0
         max_mtime = 0.0
 
-        for thread_id in sorted(self.codex_child_thread_ids):
-            path = self._codex_child_session_paths.get(thread_id)
-            if not path:
-                continue
+        def add_file(kind, identifier, path):
+            nonlocal total_bytes, max_mtime
             try:
                 stat = os.stat(path)
             except OSError:
-                continue
-
+                return
+            path_str = str(path)
             total_bytes += stat.st_size
             max_mtime = max(max_mtime, stat.st_mtime)
-            signature_parts.append(
-                f"{thread_id}:{stat.st_size}:{getattr(stat, 'st_mtime_ns', int(stat.st_mtime * 1_000_000_000))}"
-            )
+            mtime_ns = getattr(stat, "st_mtime_ns", int(stat.st_mtime * 1_000_000_000))
+            signature_parts.append(f"{kind}:{identifier}:{stat.st_size}:{mtime_ns}")
             files.append(
                 {
-                    "thread_id": thread_id,
-                    "path": path,
+                    "kind": kind,
+                    "thread_id": identifier,
+                    "path": path_str,
                     "size": stat.st_size,
                     "mtime": datetime.fromtimestamp(
                         stat.st_mtime, timezone.utc
@@ -452,6 +643,14 @@ class ProgressTracker:
                 }
             )
 
+        for thread_id in sorted(self.codex_child_thread_ids):
+            path = self._codex_child_session_paths.get(thread_id)
+            if path:
+                add_file("codex", thread_id, path)
+
+        for path in self._claude_child_session_files:
+            add_file("claude", path.stem, path)
+
         self.child_session_files = files
         self.child_total_bytes = total_bytes
         self.child_activity_signature = "|".join(signature_parts)
@@ -519,7 +718,7 @@ def atomic_write_json(data, filepath):
 
 def tail_and_parse(session_log, progress_file, poll_interval=0.5):
     """Tail session log and parse stream-json events."""
-    tracker = ProgressTracker()
+    tracker = ProgressTracker(session_log)
     last_write_state = None
 
     def state_key(state):