workstream-cli 0.0.1__py3-none-any.whl

workstream/test/test_sweep.py

@@ -0,0 +1,1196 @@
+"""Tests for workstream.commands.sweep — plan scanning and workstream update."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from textwrap import dedent
+
+import pytest
+
+from workstream.commands.sweep import (
+    scan_repo_plans,
+    _match_plans_to_workstream,
+    _auto_associate_repos,
+    _build_plan_review_prompt,
+    _parse_plan_review_response,
+    _repo_matches_slug,
+    _recompute_activity_dates,
+    _auto_classify_plans,
+)
+from workstream.config import Config, RepoConfig
+from workstream.markdown import load_workstream, parse_frontmatter, save_workstream
+from workstream.models import BranchRef, PlanRef
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture()
+def repo_with_plans(tmp_path: Path) -> Path:
+    """Create a fake repo directory with .plans/ containing 2 plan files."""
+    repo = tmp_path / 'myapp'
+    repo.mkdir()
+    plans_dir = repo / '.plans'
+    plans_dir.mkdir()
+
+    (plans_dir / 'api-v2-migration.md').write_text(dedent("""\
+        ---
+        title: API v2 Migration
+        status: active
+        workstream: api-redesign
+        ---
+
+        Migration plan content.
+    """), encoding='utf-8')
+
+    (plans_dir / 'perf-improvements.md').write_text(dedent("""\
+        ---
+        title: Performance Improvements
+        status: draft
+        ---
+
+        Perf plan content.
+    """), encoding='utf-8')
+
+    return repo
+
+
+@pytest.fixture()
+def sweep_workstreams_dir(tmp_path: Path) -> Path:
+    """Create a workstreams dir with one workstream that should match plans."""
+    ws_dir = tmp_path / 'workstreams'
+    ws_dir.mkdir()
+
+    (ws_dir / '2026-03-15-a1b2c3d4e5-api-redesign.md').write_text(dedent("""\
+        ---
+        id: 2026-03-15-a1b2c3d4e5
+        title: API Redesign
+        status: active
+        size: week
+        repos:
+          - myapp
+        created: '2026-03-15'
+        updated: '2026-03-25'
+        ---
+
+        # API Redesign
+
+        ## Thread
+        ### 2026-03-25
+        Working on it.
+
+        ## Next
+        - Finish migration
+    """), encoding='utf-8')
+
+    return ws_dir
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+def test_scan_repo_plans(repo_with_plans: Path):
+    """scan_repo_plans finds .plans/*.md and parses their frontmatter."""
+    results = scan_repo_plans(repo_with_plans / '.plans')
+    assert len(results) == 2
+
+    paths = [r['path'] for r in results]
+    assert 'api-v2-migration.md' in paths
+    assert 'perf-improvements.md' in paths
+
+    # Verify frontmatter was parsed
+    api_plan = next(r for r in results if r['path'] == 'api-v2-migration.md')
+    assert api_plan['meta']['title'] == 'API v2 Migration'
+    assert api_plan['meta']['status'] == 'active'
+    assert api_plan['meta']['workstream'] == 'api-redesign'
+
+
+def test_scan_repo_no_plans_dir(tmp_path: Path):
+    """scan_repo_plans returns [] when .plans/ doesn't exist."""
+    repo = tmp_path / 'empty-repo'
+    repo.mkdir()
+    assert scan_repo_plans(repo / '.plans') == []
+
+
+def test_match_plans_by_workstream_field(repo_with_plans: Path):
+    """Plans with a workstream field matching the slug get matched."""
+    plans = scan_repo_plans(repo_with_plans / '.plans')
+    matched = _match_plans_to_workstream(
+        'API Redesign', 'api-redesign', '2026-03-15-a1b2c3d4e5',
+        ['myapp'], 'myapp', plans,
+    )
+    # Both match: one by workstream field (slug), one by repo name fallback
+    assert len(matched) == 2
+    assert all(isinstance(p, PlanRef) for p in matched)
+    api_ref = next(p for p in matched if p.path == 'api-v2-migration.md')
+    assert api_ref.repo == 'myapp'
+    assert api_ref.status == 'active'
+
+def test_sweep_merges_explicit_and_discovered_repos(
+    sweep_workstreams_dir: Path, repo_with_plans: Path, tmp_path: Path, monkeypatch
+):
+    """Explicit config.repos and auto-discovered repo_dirs repos are both scanned.
+
+    Previously, having any entries in config.repos would skip auto-discovery
+    entirely, causing plans in non-explicit repos to be invisible.
+    """
+    # Create a second repo that will be "auto-discovered"
+    discovered_repo = tmp_path / 'repos' / 'other-app'
+    discovered_repo.mkdir(parents=True)
+    (discovered_repo / '.git').mkdir()  # fake git repo for discovery
+    plans_dir = discovered_repo / '.plans'
+    plans_dir.mkdir()
+    (plans_dir / 'extra-plan.md').write_text(
+        '---\ntitle: Extra Plan\nstatus: draft\n---\n\nExtra content.',
+        encoding='utf-8',
+    )
+
+    # Config has explicit repo + repo_dirs for discovery
+    config = Config(
+        workstreams_dir=str(sweep_workstreams_dir),
+        repos=[RepoConfig(path=str(repo_with_plans), name='myapp')],
+        repo_dirs=[str(tmp_path / 'repos')],
+    )
+    monkeypatch.setattr('workstream.commands.sweep._scan_repo_branches', lambda p: [])
+
+    from workstream.commands.sweep import _sweep_handler
+    _sweep_handler(config=config, discover=False)
+
+    # Reload the workstream — it should have plans from both repos.
+    # The explicit repo (myapp) contributes 2 plans matched by ws.repos.
+    # The discovered repo (other-app) has no workstream match, so it won't
+    # appear in the workstream's plans section, but it SHOULD be scanned.
+    # Verify by checking that sweep didn't error and the explicit repo still works.
+    ws_file = sweep_workstreams_dir / '2026-03-15-a1b2c3d4e5-api-redesign.md'
+    ws = load_workstream(ws_file)
+    assert len(ws.plans) == 2  # myapp's 2 plans still matched
+
+
+
+def test_sweep_updates_plans_section(
+    sweep_workstreams_dir: Path, repo_with_plans: Path, tmp_path: Path, monkeypatch
+):
+    """Full sweep logic: load ws, scan repo, match plans, save updated file."""
+    # Set up config to point at our fixtures
+    config = Config(
+        workstreams_dir=str(sweep_workstreams_dir),
+        repos=[RepoConfig(path=str(repo_with_plans), name='myapp')],
+    )
+    # Stub out branch scanning (no real git repo)
+    monkeypatch.setattr('workstream.commands.sweep._scan_repo_branches', lambda p: [])
+
+    from workstream.commands.sweep import _sweep_handler
+    _sweep_handler(config=config, discover=False)
+
+    # Reload the workstream and verify Plans section was updated
+    ws_file = sweep_workstreams_dir / '2026-03-15-a1b2c3d4e5-api-redesign.md'
+    ws = load_workstream(ws_file)
+    assert len(ws.plans) == 2
+    plan_paths = [p.path for p in ws.plans]
+    assert 'api-v2-migration.md' in plan_paths
+    assert 'perf-improvements.md' in plan_paths
+
+
+def test_sweep_idempotent(
+    sweep_workstreams_dir: Path, repo_with_plans: Path, tmp_path: Path, monkeypatch
+):
+    """Running sweep twice with no changes produces 0 updates on the second run."""
+    config = Config(
+        workstreams_dir=str(sweep_workstreams_dir),
+        repos=[RepoConfig(path=str(repo_with_plans), name='myapp')],
+    )
+    monkeypatch.setattr('workstream.commands.sweep._scan_repo_branches', lambda p: [])
+
+    from workstream.commands.sweep import _sweep_handler
+
+    # First sweep: should update (plans discovered)
+    _sweep_handler(config=config, discover=False)
+
+    # Second sweep: nothing changed, should be 0 updates
+    # Capture output to verify
+    import io, sys
+    buf = io.StringIO()
+    monkeypatch.setattr(sys, 'stdout', buf)
+    _sweep_handler(config=config, discover=False)
+    output = buf.getvalue()
+
+    assert 'Sweep complete: 0 workstream(s) updated.' in output, (
+        f'Expected 0 updates on idempotent sweep, got:\n{output}'
+    )
+
+
+# ---------------------------------------------------------------------------
+# Phase 1: HTML comment status markers
+# ---------------------------------------------------------------------------
+
+def test_scan_repo_plans_html_comment_status(tmp_path: Path):
+    """Legacy plans with <!-- STATUS: FINALIZED --> get meta['status'] parsed."""
+    repo = tmp_path / 'legacy-repo'
+    repo.mkdir()
+    plans_dir = repo / '.plans'
+    plans_dir.mkdir()
+
+    (plans_dir / 'old-plan.md').write_text(
+        '<!-- STATUS: FINALIZED 2025-12-15T10:30:00Z -->\n\n# Old Plan\n\nContent here.',
+        encoding='utf-8',
+    )
+    results = scan_repo_plans(plans_dir)
+    assert len(results) == 1
+    assert results[0]['meta']['status'] == 'active'  # finalized → active
+    assert results[0]['meta']['finalized_at'] == '2025-12-15T10:30:00Z'
+
+
+def test_scan_repo_plans_html_comment_no_timestamp(tmp_path: Path):
+    """HTML comment status without timestamp works."""
+    repo = tmp_path / 'repo'
+    repo.mkdir()
+    plans_dir = repo / '.plans'
+    plans_dir.mkdir()
+
+    (plans_dir / 'draft.md').write_text(
+        '<!-- STATUS: DRAFT -->\n\n# Draft Plan',
+        encoding='utf-8',
+    )
+    results = scan_repo_plans(plans_dir)
+    assert results[0]['meta']['status'] == 'draft'
+    assert 'finalized_at' not in results[0]['meta']
+
+
+def test_scan_repo_plans_html_comment_finalized_maps_to_active(tmp_path: Path):
+    """FINALIZED in HTML comment is mapped to 'active' (approved, not implemented)."""
+    repo = tmp_path / 'repo'
+    repo.mkdir()
+    plans_dir = repo / '.plans'
+    plans_dir.mkdir()
+
+    (plans_dir / 'plan.md').write_text(
+        '<!-- STATUS: FINALIZED -->\n\n# Finalized Plan',
+        encoding='utf-8',
+    )
+    results = scan_repo_plans(plans_dir)
+    assert results[0]['meta']['status'] == 'active'
+
+
+def test_scan_repo_plans_no_status(tmp_path: Path):
+    """Plans with neither frontmatter nor HTML comment → empty meta."""
+    repo = tmp_path / 'repo'
+    repo.mkdir()
+    plans_dir = repo / '.plans'
+    plans_dir.mkdir()
+
+    (plans_dir / 'bare.md').write_text('# Just a Plan\n\nNo status markers.', encoding='utf-8')
+    results = scan_repo_plans(plans_dir)
+    assert results[0]['meta'] == {}
+
+
+# ---------------------------------------------------------------------------
+# Phase 1: Auto-associate repos
+# ---------------------------------------------------------------------------
+
+def test_auto_associate_repos_exact_match(tmp_path: Path):
+    """Workstream 'fixlog' + repo 'fixlog' → ws.repos == ['fixlog']."""
+    from workstream.models import Workstream
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+    ws = Workstream(id='2026-01-01-abc', title='FixLog', status='active')
+    ws.source_path = ws_dir / f'{ws.id}-fixlog.md'
+    save_workstream(ws, ws.source_path)
+
+    count = _auto_associate_repos([ws], ['fixlog', 'other-repo'])
+    assert count == 1
+    assert ws.repos == ['fixlog']
+
+    # Verify it was persisted
+    reloaded = load_workstream(ws.source_path)
+    assert reloaded.repos == ['fixlog']
+
+
+def test_auto_associate_repos_no_false_positives(tmp_path: Path):
+    """Short slug 'top' should NOT match repo 'laptop'."""
+    from workstream.models import Workstream
+    ws = Workstream(id='2026-01-01-abc', title='Top', status='active')
+    # No source_path — can't save, but also shouldn't match
+    count = _auto_associate_repos([ws], ['laptop', 'desktop'])
+    assert count == 0
+    assert ws.repos == []
+
+
+def test_auto_associate_repos_skips_already_set(tmp_path: Path):
+    """Workstreams with existing repos are not modified."""
+    from workstream.models import Workstream
+    ws = Workstream(id='2026-01-01-abc', title='FixLog', status='active', repos=['custom-repo'])
+    count = _auto_associate_repos([ws], ['fixlog'])
+    assert count == 0
+    assert ws.repos == ['custom-repo']
+
+
+def test_auto_associate_repos_skips_repos_explicit(tmp_path: Path):
+    """Workstreams with _repos_explicit=True and empty repos are not auto-associated."""
+    from workstream.models import Workstream
+    ws = Workstream(
+        id='2026-01-01-abc', title='FinFam Fundraising', status='active',
+        repos=[], _repos_explicit=True,
+    )
+    count = _auto_associate_repos([ws], ['finfam'])
+    assert count == 0
+    assert ws.repos == []
+
+
+def test_auto_associate_repos_runs_when_not_explicit(tmp_path: Path):
+    """Workstreams with _repos_explicit=False and empty repos get auto-associated."""
+    from workstream.models import Workstream
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+    ws = Workstream(
+        id='2026-01-01-abc', title='FinFam Fundraising', status='active',
+        repos=[], _repos_explicit=False,
+    )
+    ws.source_path = ws_dir / f'{ws.id}-finfam-fundraising.md'
+    save_workstream(ws, ws.source_path)
+    count = _auto_associate_repos([ws], ['finfam'])
+    # 'finfam' matches slug 'finfam-fundraising' via prefix
+    assert count == 1
+    assert 'finfam' in ws.repos
+
+# ---------------------------------------------------------------------------
+# Phase 1: Discover repos fallback
+# ---------------------------------------------------------------------------
+
+def test_sweep_discovers_repos_from_repo_dirs(
+    sweep_workstreams_dir: Path, repo_with_plans: Path, tmp_path: Path, monkeypatch
+):
+    """When config.repos is empty, repos are discovered from repo_dirs."""
+    config = Config(
+        workstreams_dir=str(sweep_workstreams_dir),
+        repos=[],  # empty!
+        repo_dirs=[str(tmp_path)],  # must be non-empty to trigger discovery
+    )
+    monkeypatch.setattr('workstream.commands.sweep._scan_repo_branches', lambda p: [])
+    # Mock discover_repos to return our fixture repo
+    monkeypatch.setattr(
+        'workstream.repo_discovery.discover_repos',
+        lambda dirs: [repo_with_plans],
+    )
+
+    from workstream.commands.sweep import _sweep_handler
+    _sweep_handler(config=config, discover=False)
+
+    # The workstream should still get plans matched (repo name = 'myapp')
+    ws_file = sweep_workstreams_dir / '2026-03-15-a1b2c3d4e5-api-redesign.md'
+    ws = load_workstream(ws_file)
+    assert len(ws.plans) == 2
+
+
+def test_sweep_deduplicates_same_remote_repos(
+    sweep_workstreams_dir: Path, tmp_path: Path, monkeypatch
+):
+    """Repos sharing the same remote URL are deduplicated — keep more plans."""
+    # Create two 'repos' with .plans/ dirs of different sizes
+    repo_a = tmp_path / 'myapp'
+    repo_a.mkdir()
+    plans_a = repo_a / '.plans'
+    plans_a.mkdir()
+    (plans_a / 'plan1.md').write_text('---\ntitle: P1\nstatus: active\nworkstream: api-redesign\n---\n', encoding='utf-8')
+    (plans_a / 'plan2.md').write_text('---\ntitle: P2\nstatus: draft\n---\n', encoding='utf-8')
+
+    repo_b = tmp_path / 'myapp-clone'
+    repo_b.mkdir()
+    plans_b = repo_b / '.plans'
+    plans_b.mkdir()
+    (plans_b / 'plan1.md').write_text('---\ntitle: P1\nstatus: active\nworkstream: api-redesign\n---\n', encoding='utf-8')
+
+    config = Config(
+        workstreams_dir=str(sweep_workstreams_dir),
+        repos=[],
+    )
+    monkeypatch.setattr('workstream.commands.sweep._scan_repo_branches', lambda p: [])
+    monkeypatch.setattr(
+        'workstream.repo_discovery.discover_repos',
+        lambda dirs: [repo_a, repo_b],
+    )
+    # Both repos return the same remote URL
+    monkeypatch.setattr('workstream.git.remote_url', lambda path, remote='origin': 'git@github.com:test/myapp.git')
+
+    from workstream.commands.sweep import _sweep_handler
+    _sweep_handler(config=config, discover=False)
+
+    # repo_a has 2 plans, repo_b has 1 — repo_a wins
+    ws_file = sweep_workstreams_dir / '2026-03-15-a1b2c3d4e5-api-redesign.md'
+    ws = load_workstream(ws_file)
+    # Only plans from myapp (the winner), not myapp-clone
+    assert all(p.repo == 'myapp' for p in ws.plans)
+
+
+# ---------------------------------------------------------------------------
+# Phase 3: Plan review prompt and response parsing
+# ---------------------------------------------------------------------------
+
+def test_build_plan_review_prompt():
+    """Prompt includes plan content, git context, and workstream context."""
+    prompt = _build_plan_review_prompt(
+        ws_title='FixLog',
+        ws_context='Status: active\n  [2026-03-25] Working on auth',
+        git_context='Repo: fixlog, default branch: main\nRecent commits:\n  2026-03-25 Add auth module',
+        plan_entries=[
+            {'filename': 'auth-plan.md', 'marker': 'finalized 2026-03-20', 'content': 'Add authentication...'},
+            {'filename': 'db-migration.md', 'marker': '', 'content': 'Migrate to postgres...'},
+        ],
+    )
+    assert 'FixLog' in prompt
+    assert 'auth-plan.md' in prompt
+    assert 'db-migration.md' in prompt
+    assert 'Add authentication' in prompt
+    assert 'Add auth module' in prompt
+    assert 'finalized 2026-03-20' in prompt
+
+
+def test_build_plan_review_prompt_prefers_summary():
+    """When plan has a summary in meta, prompt uses that, not full content."""
+    prompt = _build_plan_review_prompt(
+        ws_title='Test',
+        ws_context='Status: active',
+        git_context='Repo: test',
+        plan_entries=[
+            {'filename': 'plan.md', 'marker': '', 'content': 'This is the summary from meta'},
+        ],
+    )
+    assert 'This is the summary from meta' in prompt
+
+
+def test_parse_plan_review_response_valid():
+    """Valid JSON array of classifications."""
+    response = '''[
+        {"plan": "auth-plan.md", "status": "implemented", "reason": "Commits on 2026-03-25", "ideas": []},
+        {"plan": "db-migration.md", "status": "active", "reason": "No commits yet", "ideas": ["Consider using Alembic"]}  
+    ]'''
+    results = _parse_plan_review_response(response)
+    assert len(results) == 2
+    assert results[0]['plan'] == 'auth-plan.md'
+    assert results[0]['status'] == 'implemented'
+    assert results[0]['ideas'] == []
+    assert results[1]['status'] == 'active'
+    assert results[1]['ideas'] == ['Consider using Alembic']
+
+
+def test_parse_plan_review_response_with_fences():
+    """JSON wrapped in markdown code fences."""
+    response = '''```json
+[{"plan": "x.md", "status": "obsolete", "reason": "replaced", "ideas": []}]
+```'''
+    results = _parse_plan_review_response(response)
+    assert len(results) == 1
+    assert results[0]['status'] == 'obsolete'
+
+
+def test_parse_plan_review_response_invalid():
+    """Garbage input returns empty list."""
+    assert _parse_plan_review_response('not json at all') == []
+    assert _parse_plan_review_response('') == []
+
+
+def test_parse_plan_review_response_rejects_bad_status():
+    """Entries with invalid status values are filtered out."""
+    response = '[{"plan": "x.md", "status": "unknown", "reason": "test", "ideas": []}]'
+    assert _parse_plan_review_response(response) == []
+
+
+def test_review_dispatches_ideas(tmp_path: Path, monkeypatch):
+    """Review handler dispatches ideas from classifications to workstream files."""
+    from unittest.mock import MagicMock
+    from workstream.models import Workstream
+
+    # Set up workstream
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+    ws = Workstream(
+        id='2026-01-01-abc', title='FixLog', status='active',
+        repos=['fixlog'],
+    )
+    ws.source_path = ws_dir / f'{ws.id}-fixlog.md'
+    save_workstream(ws, ws.source_path)
+
+    # Set up fake repo with a plan
+    repo_path = tmp_path / 'fixlog'
+    repo_path.mkdir()
+    plans_dir = repo_path / '.plans'
+    plans_dir.mkdir()
+    (plans_dir / 'auth-plan.md').write_text('# Auth Plan\nAdd authentication.', encoding='utf-8')
+
+    repo_data = {
+        'fixlog': {
+            'plans': [{'path': 'auth-plan.md', 'meta': {'status': 'finalized'}}],
+            'branches': [],
+            'path': repo_path,
+            'plans_dir': plans_dir,
+        },
+    }
+
+    # Mock LLM agent
+    mock_agent = MagicMock()
+    mock_agent.prompt.return_value = '''[{
+        "plan": "auth-plan.md",
+        "status": "implemented",
+        "reason": "Auth module committed 2026-03-25",
+        "ideas": ["Add OAuth2 support", "Rate limiting for auth endpoints"]
+    }]'''
+
+    mock_config = MagicMock()
+    mock_config.get_llm_agent.return_value = 'test'
+    mock_config.llm_discover_model = None
+
+    monkeypatch.setattr('workstream.llm.LLMAgent', lambda name: mock_agent)
+
+    from workstream.commands.sweep import _review_plans_handler
+    _review_plans_handler(mock_config, [ws], repo_data, ws_dir, batch=True)
+
+    # Reload and check ideas were dispatched
+    reloaded = load_workstream(ws.source_path)
+    idea_texts = [i.text for i in reloaded.ideas]
+    assert 'Add OAuth2 support' in idea_texts
+    assert 'Rate limiting for auth endpoints' in idea_texts
+
+    # Check log entries
+    log_events = [l.event for l in reloaded.log]
+    assert 'plan-reviewed' in log_events
+    assert 'plan-idea' in log_events
+
+
+def test_review_logs_all_classifications(tmp_path: Path, monkeypatch):
+    """Every plan gets a log entry regardless of status or ideas."""
+    from unittest.mock import MagicMock
+    from workstream.models import Workstream
+
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+    ws = Workstream(
+        id='2026-01-01-abc', title='TestWS', status='active',
+        repos=['testrepo'],
+    )
+    ws.source_path = ws_dir / f'{ws.id}-testws.md'
+    save_workstream(ws, ws.source_path)
+
+    repo_path = tmp_path / 'testrepo'
+    repo_path.mkdir()
+    plans_dir = repo_path / '.plans'
+    plans_dir.mkdir()
+    (plans_dir / 'a.md').write_text('# Plan A', encoding='utf-8')
+    (plans_dir / 'b.md').write_text('# Plan B', encoding='utf-8')
+
+    repo_data = {
+        'testrepo': {
+            'plans': [
+                {'path': 'a.md', 'meta': {}},
+                {'path': 'b.md', 'meta': {}},
+            ],
+            'branches': [],
+            'path': repo_path,
+            'plans_dir': plans_dir,
+        },
+    }
+
+    mock_agent = MagicMock()
+    mock_agent.prompt.return_value = '''[
+        {"plan": "a.md", "status": "implemented", "reason": "done", "ideas": []},
+        {"plan": "b.md", "status": "obsolete", "reason": "replaced", "ideas": []}
+    ]'''
+
+    mock_config = MagicMock()
+    mock_config.get_llm_agent.return_value = 'test'
+    mock_config.llm_discover_model = None
+
+    monkeypatch.setattr('workstream.llm.LLMAgent', lambda name: mock_agent)
+
+    from workstream.commands.sweep import _review_plans_handler
+    _review_plans_handler(mock_config, [ws], repo_data, ws_dir, batch=True)
+
+    reloaded = load_workstream(ws.source_path)
+    review_logs = [l for l in reloaded.log if l.event == 'plan-reviewed']
+    assert len(review_logs) == 2
+    assert 'a.md' in review_logs[0].detail
+    assert 'b.md' in review_logs[1].detail
+
+
+# ---------------------------------------------------------------------------
+# _repo_matches_slug
+# ---------------------------------------------------------------------------
+
+class TestRepoMatchesSlug:
+    """Unit tests for the slug-based repo matching helper."""
+
+    def test_exact_match(self):
+        assert _repo_matches_slug('workstream', 'workstream') is True
+
+    def test_prefix_repo_shorter(self):
+        # repo 'workstream' matches slug 'workstream-tool'
+        assert _repo_matches_slug('workstream', 'workstream-tool') is True
+
+    def test_prefix_slug_shorter(self):
+        # slug 'workstream' matches repo 'workstream-cli'
+        assert _repo_matches_slug('workstream-cli', 'workstream') is True
+
+    def test_no_match_unrelated(self):
+        assert _repo_matches_slug('django', 'workstream') is False
+
+    def test_no_substring_without_dash(self):
+        # 'stream' is a substring of 'workstream' but not a word-prefix
+        assert _repo_matches_slug('workstream', 'stream') is False
+
+    def test_short_slug_exact_match(self):
+        # Short names still match exactly
+        assert _repo_matches_slug('bq', 'bq') is True
+
+    def test_short_slug_no_false_positive(self):
+        # 'bq' should NOT match 'bq-server' (too short for prefix)
+        assert _repo_matches_slug('bq-server', 'bq') is False
+
+    def test_short_repo_no_false_positive(self):
+        # short repo name 'top' should NOT match slug 'top-server'
+        assert _repo_matches_slug('top', 'top-server') is False
+
+    def test_one_side_long_enough(self):
+        # repo 'tool' (4 chars) matches slug 'tool-cli' via prefix
+        assert _repo_matches_slug('tool', 'tool-cli') is True
+
+    def test_both_long_enough_prefix(self):
+        # Both >= 4 chars, prefix match in either direction
+        assert _repo_matches_slug('infra', 'infra-deploy') is True
+        assert _repo_matches_slug('infra-deploy', 'infra') is True
+
+
+# ---------------------------------------------------------------------------
+# _auto_associate_repos with prefix matching
+# ---------------------------------------------------------------------------
+
+def test_auto_associate_repos_prefix_match(tmp_path: Path):
+    """'Workstream Tool' + repo 'workstream' → associated via prefix."""
+    from workstream.models import Workstream
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+    ws = Workstream(id='2026-01-01-abc', title='Workstream Tool', status='active')
+    ws.source_path = ws_dir / f'{ws.id}-workstream-tool.md'
+    save_workstream(ws, ws.source_path)
+
+    count = _auto_associate_repos([ws], ['workstream', 'other-repo'])
+    assert count == 1
+    assert 'workstream' in ws.repos
+
+
+def test_auto_associate_repos_short_slug_no_prefix(tmp_path: Path):
+    """'Top' + repo 'top-server' → NOT associated (short slug, not exact)."""
+    from workstream.models import Workstream
+    ws = Workstream(id='2026-01-01-abc', title='Top', status='active')
+    count = _auto_associate_repos([ws], ['top-server'])
+    assert count == 0
+    assert ws.repos == []
+
+
+# ---------------------------------------------------------------------------
+# _recompute_activity_dates with slug-matched repos
+# ---------------------------------------------------------------------------
+
+def test_recompute_activity_dates_slug_match(tmp_path: Path, monkeypatch):
+    """Workstream 'Workstream Tool' picks up commits from repo 'workstream'."""
+    from workstream.models import Workstream
+    from workstream.markdown import write_frontmatter
+
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    # Create a workstream file with NO repos and an old last_activity
+    meta = {
+        'id': '2026-01-01-abc',
+        'title': 'Workstream Tool',
+        'status': 'active',
+        'repos': [],
+        'first_activity': '2026-01-01',
+        'last_activity': '2026-03-28',
+        'created': '2026-01-01',
+    }
+    body = '\n# Workstream Tool\n\n## Thread\n### 2026-01-01\nStarted.\n'
+    ws_file = ws_dir / '2026-01-01-abc-workstream-tool.md'
+    ws_file.write_text(write_frontmatter(meta, body), encoding='utf-8')
+
+    # Create a fake repo dir and mock recent_commits to return a newer date
+    repo_dir = tmp_path / 'workstream'
+    repo_dir.mkdir()
+    monkeypatch.setattr(
+        'workstream.git.recent_commits',
+        lambda rpath, since: [{'date': '2026-03-31', 'subject': 'fix'}],
+    )
+
+    repo_paths = {'workstream': repo_dir}
+    _recompute_activity_dates(ws_dir, repo_paths=repo_paths)
+
+    # Verify the workstream file was updated with the newer date
+    updated_meta, _ = parse_frontmatter(ws_file.read_text(encoding='utf-8'))
+    assert updated_meta['last_activity'] == '2026-03-31'
+
+
+def test_recompute_activity_dates_explicit_repos(tmp_path: Path, monkeypatch):
+    """Explicit ws.repos still works — both explicit and slug-matched contribute."""
+    from workstream.models import Workstream
+    from workstream.markdown import write_frontmatter
+
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    meta = {
+        'id': '2026-01-01-abc',
+        'title': 'My App',
+        'status': 'active',
+        'repos': ['myapp'],
+        'first_activity': '2026-01-01',
+        'last_activity': '2026-03-01',
+        'created': '2026-01-01',
+    }
+    body = '\n# My App\n\n## Thread\n### 2026-01-01\nStarted.\n'
+    ws_file = ws_dir / '2026-01-01-abc-my-app.md'
+    ws_file.write_text(write_frontmatter(meta, body), encoding='utf-8')
+
+    repo_dir = tmp_path / 'myapp'
+    repo_dir.mkdir()
+    monkeypatch.setattr(
+        'workstream.git.recent_commits',
+        lambda rpath, since: [{'date': '2026-03-30', 'subject': 'update'}],
+    )
+
+    repo_paths = {'myapp': repo_dir}
+    _recompute_activity_dates(ws_dir, repo_paths=repo_paths)
+
+    updated_meta, _ = parse_frontmatter(ws_file.read_text(encoding='utf-8'))
+    assert updated_meta['last_activity'] == '2026-03-30'
+
+
+def test_match_plans_carries_metadata(repo_with_plans: Path):
+    """PlanRef from _match_plans_to_workstream carries plan_type and guidance."""
+    # Create a plan with plan_type and workstream_guidance in frontmatter
+    plans_dir = repo_with_plans / '.plans'
+    (plans_dir / 'typed-plan.md').write_text(
+        '---\ntitle: Typed Plan\nstatus: active\nworkstream: api-redesign\n'
+        'plan_type: project\nworkstream_guidance: new-peer\n---\n\nContent.',
+        encoding='utf-8',
+    )
+    plans = scan_repo_plans(plans_dir)
+    matched = _match_plans_to_workstream(
+        'API Redesign', 'api-redesign', '2026-03-15-a1b2c3d4e5',
+        ['myapp'], 'myapp', plans,
+    )
+    typed = next(p for p in matched if p.path == 'typed-plan.md')
+    assert typed.plan_type == 'project'
+    assert typed.guidance == 'new-peer'
+
+
+def test_match_plans_no_metadata_defaults_empty(repo_with_plans: Path):
+    """PlanRef defaults plan_type and guidance to '' for legacy plans."""
+    plans = scan_repo_plans(repo_with_plans / '.plans')
+    matched = _match_plans_to_workstream(
+        'API Redesign', 'api-redesign', '2026-03-15-a1b2c3d4e5',
+        ['myapp'], 'myapp', plans,
+    )
+    api_ref = next(p for p in matched if p.path == 'api-v2-migration.md')
+    assert api_ref.plan_type == ''
+    assert api_ref.guidance == ''
+
+
+def test_match_plans_title_match(tmp_path: Path):
+    """Plan with workstream title matches the correct workstream."""
+    plans = [{'path': 'plan.md', 'meta': {'workstream': 'FinFam Product', 'status': 'active', 'title': 'X'}}]
+    matched = _match_plans_to_workstream(
+        'FinFam Product', 'finfam-product', '2026-01-01-abc',
+        ['finfam'], 'finfam', plans,
+    )
+    assert len(matched) == 1
+    assert matched[0].path == 'plan.md'
+
+
+def test_match_plans_title_rejects_wrong_workstream():
+    """Plan assigned to one workstream is NOT included in another."""
+    plans = [{'path': 'plan.md', 'meta': {'workstream': 'FinFam Product', 'status': 'active', 'title': 'X'}}]
+    matched = _match_plans_to_workstream(
+        'FinFam Fundraising', 'finfam-fundraising', '2026-01-02-def',
+        ['finfam'], 'finfam', plans,
+    )
+    assert len(matched) == 0
+
+
+def test_match_plans_by_id():
+    """Plan whose workstream field is a workstream ID matches by ID."""
+    plans = [{'path': 'plan.md', 'meta': {'workstream': '2026-01-01-abc', 'status': 'draft', 'title': 'Y'}}]
+    matched = _match_plans_to_workstream(
+        'FinFam Product', 'finfam-product', '2026-01-01-abc',
+        ['finfam'], 'finfam', plans,
+    )
+    assert len(matched) == 1
+
+
+def test_match_plans_by_slug():
+    """Plan whose workstream field is a slug matches via slugification."""
+    plans = [{'path': 'plan.md', 'meta': {'workstream': 'finfam-product', 'status': 'active', 'title': 'Z'}}]
+    matched = _match_plans_to_workstream(
+        'FinFam Product', 'finfam-product', '2026-01-01-abc',
+        ['finfam'], 'finfam', plans,
+    )
+    assert len(matched) == 1
+
+
+def test_match_plans_no_field_repo_match():
+    """Plan with no workstream field falls back to repo matching."""
+    plans = [{'path': 'plan.md', 'meta': {'status': 'active', 'title': 'Z'}}]
+    matched = _match_plans_to_workstream(
+        'FinFam Product', 'finfam-product', '2026-01-01-abc',
+        ['finfam'], 'finfam', plans,
+    )
+    assert len(matched) == 1
+
+
+def test_match_plans_no_field_repo_no_match():
+    """Plan with no workstream field and repo NOT in ws_repos is excluded."""
+    plans = [{'path': 'plan.md', 'meta': {'status': 'active', 'title': 'Z'}}]
+    matched = _match_plans_to_workstream(
+        'Unrelated WS', 'unrelated-ws', '2026-01-01-xyz',
+        ['other-repo'], 'finfam', plans,
+    )
+    assert len(matched) == 0
+
+def test_auto_classify_writes_implemented(tmp_path: Path):
+    """_auto_classify_plans writes status=implemented to plan file frontmatter."""
+    plans_dir = tmp_path / '.plans'
+    plans_dir.mkdir()
+    plan_file = plans_dir / 'feature.md'
+    plan_file.write_text(
+        '---\ntitle: Feature\nstatus: active\n---\n\nPlan content.',
+        encoding='utf-8',
+    )
+
+    plan = PlanRef(
+        repo='myrepo', path='feature.md', status='active',
+        title='Feature', date='2026-03-30', signal='likely-implemented',
+    )
+    repo_data = {'myrepo': {'plans_dir': plans_dir, 'path': tmp_path}}
+
+    classified = _auto_classify_plans([plan], repo_data)
+
+    assert len(classified) == 1
+    assert classified[0].status == 'implemented'
+
+    # Verify the file was updated
+    from workstream.markdown import parse_frontmatter
+    meta, _ = parse_frontmatter(plan_file.read_text(encoding='utf-8'))
+    assert meta['status'] == 'implemented'
+    assert 'reviewed' in meta
+    assert 'review_note' in meta
+
+
+def test_auto_classify_skips_non_signal(tmp_path: Path):
+    """_auto_classify_plans skips plans without likely-implemented signal."""
+    plans_dir = tmp_path / '.plans'
+    plans_dir.mkdir()
+    plan_file = plans_dir / 'stale.md'
+    plan_file.write_text(
+        '---\ntitle: Stale\nstatus: active\n---\n\nContent.',
+        encoding='utf-8',
+    )
+
+    plan = PlanRef(
+        repo='myrepo', path='stale.md', status='active',
+        title='Stale', date='2026-03-30', signal='stale',
+    )
+    repo_data = {'myrepo': {'plans_dir': plans_dir, 'path': tmp_path}}
+
+    classified = _auto_classify_plans([plan], repo_data)
+    assert classified == []
+
+    # File should be unchanged
+    from workstream.markdown import parse_frontmatter
+    meta, _ = parse_frontmatter(plan_file.read_text(encoding='utf-8'))
+    assert meta['status'] == 'active'
+
+
+def test_find_matching_branches():
+    """_find_matching_branches finds branches matching slugified plan title."""
+    from workstream.commands.sweep import _find_matching_branches
+    branches = [
+        BranchRef(repo='r', branch='refactor-config-parser', ahead=3),
+        BranchRef(repo='r', branch='feature-unrelated', ahead=1),
+    ]
+    matched = _find_matching_branches('Refactor Config Parser', branches)
+    assert len(matched) == 1
+    assert matched[0].branch == 'refactor-config-parser'
+
+
+def test_find_matching_branches_short_title():
+    """Short plan titles don't cause false positive branch matches."""
+    from workstream.commands.sweep import _find_matching_branches
+    branches = [BranchRef(repo='r', branch='fix-ab-thing', ahead=1)]
+    # Title 'ab' is too short (< 4 chars slug) -- should return empty
+    assert _find_matching_branches('Ab', branches) == []
+
+
+def test_build_sweep_review_manifest_triage(tmp_path: Path):
+    """Manifest includes findings-scoped sections for workstreams with activity."""
+    from workstream.commands.sweep import _build_sweep_review_manifest, SweepFindings
+    from workstream.models import Workstream, BranchRef
+
+    proj_plan = PlanRef(repo='myrepo', path='proj.md', status='active',
+                        title='Big Project', date='2026-03-30',
+                        plan_type='project', guidance='new-peer')
+    tac_plan = PlanRef(repo='myrepo', path='tac.md', status='active',
+                       title='Quick Fix', date='2026-03-30',
+                       plan_type='tactical', guidance='keep-current')
+    stale_plan = PlanRef(repo='myrepo', path='stale.md', status='active',
+                         title='Old Thing', date='2026-01-01',
+                         signal='stale')
+
+    ws = Workstream(
+        id='2026-01-01-abc',
+        title='Test Stream',
+        status='active',
+        repos=['myrepo'],
+        plans=[proj_plan, tac_plan, stale_plan],
+        branches=[
+            BranchRef(repo='myrepo', branch='big-project', ahead=5),
+        ],
+    )
+
+    repo_data = {
+        'myrepo': {
+            'plans': [], 'branches': [],
+            'path': tmp_path, 'plans_dir': tmp_path / '.plans',
+        },
+    }
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    findings = {
+        '2026-01-01-abc': SweepFindings(
+            newly_matched=[proj_plan, tac_plan],
+            new_signals=[stale_plan],
+            auto_classified=[],
+        ),
+    }
+
+    manifest = _build_sweep_review_manifest([ws], repo_data, ws_dir,
+                                            findings=findings, cutoff='2026-03-28')
+
+    # Header shows cutoff
+    assert 'Cutoff: 2026-03-28' in manifest
+    # Workstream header
+    assert '### Test Stream' in manifest
+    # Discovered plans section with plan files
+    assert '**Discovered plans:**' in manifest
+    assert 'proj.md' in manifest
+    # Project plan with branch match
+    assert 'big-project' in manifest
+    assert 'track implementation' in manifest
+    # Tactical plan tagged
+    assert 'tac.md' in manifest
+    assert 'tactical' in manifest
+    # Signals section
+    assert '**Signals:**' in manifest
+    assert 'stale.md' in manifest
+    assert 'Still relevant?' in manifest
+    # Instructions reference tool access
+    assert 'git log' in manifest
+
+    # Paths include filesystem paths for the agent
+    assert 'Paths:' in manifest
+    assert f'myrepo={tmp_path}' in manifest
+
+
+def test_build_sweep_review_manifest_with_notes(tmp_path: Path):
+    """Manifest includes Changed Notes section when notes activity exists."""
+    from workstream.commands.sweep import _build_sweep_review_manifest, SweepFindings
+    from workstream.models import Workstream
+
+    ws = Workstream(
+        id='2026-01-01-abc',
+        title='Test Stream',
+        status='active',
+        repos=['myrepo'],
+    )
+    repo_data = {
+        'myrepo': {
+            'plans': [], 'branches': [],
+            'path': tmp_path, 'plans_dir': tmp_path / '.plans',
+        },
+    }
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    changed_notes = [
+        {'path': '/home/user/notes/sprint.md', 'name': 'sprint.md', 'status': 'committed'},
+        {'path': '/home/user/notes/meeting.md', 'name': 'meeting.md', 'status': 'modified'},
+    ]
+    notes_root = Path('/home/user/notes')
+
+    # No findings, but notes present — manifest should still render
+    manifest = _build_sweep_review_manifest([ws], repo_data, ws_dir,
+                                            findings={}, cutoff='2026-03-28',
+                                            changed_notes=changed_notes,
+                                            notes_root=notes_root)
+
+    assert '### Changed Notes' in manifest
+    assert 'Notes root: /home/user/notes' in manifest
+    assert 'sprint.md' in manifest
+    assert 'Committed since 2026-03-28' in manifest
+    assert 'meeting.md' in manifest
+    assert 'Unstaged changes' in manifest
+
+
+def test_build_sweep_review_manifest_no_notes(tmp_path: Path):
+    """Manifest omits Changed Notes section when no notes activity."""
+    from workstream.commands.sweep import _build_sweep_review_manifest, SweepFindings
+    from workstream.models import Workstream
+
+    ws = Workstream(
+        id='2026-01-01-abc',
+        title='Test Stream',
+        status='active',
+    )
+    repo_data = {}
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    manifest = _build_sweep_review_manifest([ws], repo_data, ws_dir,
+                                            findings={}, cutoff='2026-03-28',
+                                            changed_notes=None)
+
+    assert '### Changed Notes' not in manifest
+    assert 'No activity detected' in manifest
+
+
+# ── Idea dedup ──────────────────────────────────────────────────────────────
+
+def test_idea_is_duplicate_exact():
+    from workstream.commands.sweep import _idea_is_duplicate
+    from workstream.models import IdeaEntry
+    existing = [IdeaEntry(date='2026-03-28', text='Add caching layer')]
+    assert _idea_is_duplicate('Add caching layer', existing) is True
+
+
+def test_idea_is_duplicate_case_insensitive():
+    from workstream.commands.sweep import _idea_is_duplicate
+    from workstream.models import IdeaEntry
+    existing = [IdeaEntry(date='2026-03-28', text='Add Caching Layer')]
+    assert _idea_is_duplicate('add caching layer', existing) is True
+
+
+def test_idea_is_duplicate_substring():
+    from workstream.commands.sweep import _idea_is_duplicate
+    from workstream.models import IdeaEntry
+    existing = [IdeaEntry(date='2026-03-28', text='Add a caching layer to reduce API latency')]
+    assert _idea_is_duplicate('add a caching layer to reduce api latency by 50%', existing) is True
+
+
+def test_idea_is_duplicate_short_not_substring():
+    """Short ideas (<=20 chars) only match on exact equality, not substring."""
+    from workstream.commands.sweep import _idea_is_duplicate
+    from workstream.models import IdeaEntry
+    existing = [IdeaEntry(date='2026-03-28', text='Add cache')]
+    assert _idea_is_duplicate('Add cache layer', existing) is False
+
+
+def test_idea_is_duplicate_novel():
+    from workstream.commands.sweep import _idea_is_duplicate
+    from workstream.models import IdeaEntry
+    existing = [IdeaEntry(date='2026-03-28', text='Add caching layer')]
+    assert _idea_is_duplicate('Refactor auth middleware', existing) is False
+
+
+# ── Manifest code velocity warning ────────────────────────────────────────
+
+def test_manifest_code_velocity_warning_stale(tmp_path: Path):
+    """Workstream with repos but stale code_last_activity gets a warning."""
+    from workstream.commands.sweep import _build_sweep_review_manifest, SweepFindings
+    from workstream.models import Workstream
+
+    ws = Workstream(
+        id='2026-01-01-abc',
+        title='Stale Code',
+        status='active',
+        repos=['myrepo'],
+        code_last_activity='2026-01-15',
+    )
+    repo_data = {
+        'myrepo': {
+            'plans': [], 'branches': [],
+            'path': tmp_path, 'plans_dir': tmp_path / '.plans',
+        },
+    }
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    findings = {
+        '2026-01-01-abc': SweepFindings(
+            newly_matched=[], new_signals=[], auto_classified=[],
+        ),
+    }
+
+    manifest = _build_sweep_review_manifest([ws], repo_data, ws_dir,
+                                            findings=findings, cutoff='2026-03-01')
+    assert 'No code commits since 2026-01-15' in manifest
+
+
+def test_manifest_code_velocity_warning_no_code(tmp_path: Path):
+    """Workstream with repos but no code_last_activity at all."""
+    from workstream.commands.sweep import _build_sweep_review_manifest, SweepFindings
+    from workstream.models import Workstream
+
+    ws = Workstream(
+        id='2026-01-01-abc',
+        title='No Code',
+        status='active',
+        repos=['myrepo'],
+    )
+    repo_data = {
+        'myrepo': {
+            'plans': [], 'branches': [],
+            'path': tmp_path, 'plans_dir': tmp_path / '.plans',
+        },
+    }
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    findings = {
+        '2026-01-01-abc': SweepFindings(
+            newly_matched=[], new_signals=[], auto_classified=[],
+        ),
+    }
+
+    manifest = _build_sweep_review_manifest([ws], repo_data, ws_dir,
+                                            findings=findings, cutoff='2026-03-01')
+    assert 'No code commits detected in associated repos' in manifest
+
+
+def test_manifest_code_velocity_no_warning_when_recent(tmp_path: Path):
+    """Workstream with recent code activity gets no warning."""
+    from workstream.commands.sweep import _build_sweep_review_manifest, SweepFindings
+    from workstream.models import Workstream
+
+    ws = Workstream(
+        id='2026-01-01-abc',
+        title='Active Code',
+        status='active',
+        repos=['myrepo'],
+        code_last_activity='2026-03-29',
+    )
+    repo_data = {
+        'myrepo': {
+            'plans': [], 'branches': [],
+            'path': tmp_path, 'plans_dir': tmp_path / '.plans',
+        },
+    }
+    ws_dir = tmp_path / 'ws'
+    ws_dir.mkdir()
+
+    findings = {
+        '2026-01-01-abc': SweepFindings(
+            newly_matched=[], new_signals=[], auto_classified=[],
+        ),
+    }
+
+    manifest = _build_sweep_review_manifest([ws], repo_data, ws_dir,
+                                            findings=findings, cutoff='2026-03-01')
+    assert 'No code commits' not in manifest