@stylusnexus/work-plan 2026.6.9-1

package/skills/work-plan/tests/test_plan_status_stamp.py

@@ -0,0 +1,70 @@
+"""Stamp / draft behaviour for plan-status (offline)."""
+import io
+import unittest
+import sys
+import tempfile
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import plan_status
+from lib.status_header import BEGIN
+
+PLAN = (
+    "# Idea Mode Implementation Plan\n\n"
+    "**Files:**\n"
+    "- Create: `src/new.ts`\n"
+    "- Create: `src/missing.ts`\n"
+    "- [ ] Step 1\n"
+)
+
+
+class StampBehaviourTest(unittest.TestCase):
+    def _repo(self, d):
+        root = Path(d)
+        (root / "docs/superpowers/plans").mkdir(parents=True)
+        self.plan_path = root / "docs/superpowers/plans/2026-03-16-idea-mode-ui.md"
+        self.plan_path.write_text(PLAN)
+        (root / "src").mkdir()
+        (root / "src/new.ts").write_text("x")
+        return root
+
+    def _run(self, root, args):
+        with mock.patch("commands.plan_status.git_state.path_last_commit_date",
+                        return_value=None), \
+             mock.patch("commands.plan_status.Path.cwd", return_value=root):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = plan_status.run(args)
+        return rc, buf.getvalue()
+
+    def test_draft_does_not_write(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out = self._run(root, ["--stamp", "--draft"])
+            self.assertEqual(rc, 0)
+            self.assertIn("would stamp", out)
+            self.assertNotIn(BEGIN, self.plan_path.read_text())
+
+    def test_stamp_writes_block(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            rc, out = self._run(root, ["--stamp"])
+            self.assertEqual(rc, 0)
+            self.assertIn("stamped", out)
+            self.assertIn(BEGIN, self.plan_path.read_text())
+
+    def test_stamp_is_idempotent_on_disk(self):
+        with tempfile.TemporaryDirectory() as d:
+            root = self._repo(d)
+            self._run(root, ["--stamp"])
+            first = self.plan_path.read_text()
+            self._run(root, ["--stamp"])
+            self.assertEqual(first, self.plan_path.read_text())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_plugin_manifests.py

@@ -0,0 +1,38 @@
+"""Plugin manifest(s) parse, carry required fields, and match VERSION (CalVer).
+
+Offline. The Codex manifest (.codex-plugin/plugin.json) lands in Phase 2; this
+test tolerates its absence and only asserts equality when it exists.
+"""
+import json
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+
+
+def _load(rel):
+    return json.loads((REPO_ROOT / rel).read_text(encoding="utf-8"))
+
+
+class ClaudeManifestTest(unittest.TestCase):
+    def test_required_fields(self):
+        m = _load(".claude-plugin/plugin.json")
+        self.assertEqual(m["name"], "work-plan")
+        self.assertTrue(m["description"])
+        self.assertEqual(m["license"], "MIT")
+
+    def test_version_matches_VERSION(self):
+        m = _load(".claude-plugin/plugin.json")
+        ver = (REPO_ROOT / "VERSION").read_text(encoding="utf-8").strip()
+        self.assertEqual(m["version"], ver)   # CalVer string, not semver
+
+    def test_codex_manifest_agrees_when_present(self):
+        codex = REPO_ROOT / ".codex-plugin" / "plugin.json"
+        if not codex.exists():
+            self.skipTest("Codex manifest is Phase 2")
+        self.assertEqual(_load(".codex-plugin/plugin.json")["version"],
+                         _load(".claude-plugin/plugin.json")["version"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_reconcile_actions.py

@@ -0,0 +1,60 @@
+"""Tests for reconcile action selection + target/body construction + unsatisfied paths."""
+import unittest
+import sys
+from datetime import date
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.manifest import DeclaredPath, unsatisfied_paths
+from lib.reconcile_actions import dead_rows, partial_rows, archive_dest, issue_for
+
+
+def _row(rel, verdict, present=0, declared=0):
+    return {"rel": rel, "verdict": verdict, "files_present": present,
+            "files_declared": declared, "glyph": "?", "rationale": ""}
+
+
+class SelectionTest(unittest.TestCase):
+    def test_dead_and_partial_filters(self):
+        rows = [_row("a.md", "dead"), _row("b.md", "partial", 3, 9),
+                _row("c.md", "shipped", 9, 9)]
+        self.assertEqual([r["rel"] for r in dead_rows(rows)], ["a.md"])
+        self.assertEqual([r["rel"] for r in partial_rows(rows)], ["b.md"])
+
+
+class ArchiveDestTest(unittest.TestCase):
+    def test_dest_under_archive_abandoned(self):
+        self.assertEqual(
+            archive_dest("docs/superpowers/plans/2026-01-01-x.md"),
+            "docs/superpowers/plans/archive/abandoned/2026-01-01-x.md")
+
+
+class UnsatisfiedPathsTest(unittest.TestCase):
+    def test_returns_only_missing(self):
+        decls = [DeclaredPath("create", "src/here.ts"),
+                 DeclaredPath("create", "src/gone.ts"),
+                 DeclaredPath("modify", "src/old.ts")]
+        missing = unsatisfied_paths(
+            decls, Path("/repo"), date(2026, 3, 1),
+            exists=lambda rel: rel == "src/here.ts",
+            committed_since=lambda rel: False)
+        self.assertEqual({d.path for d in missing}, {"src/gone.ts", "src/old.ts"})
+
+
+class IssueForTest(unittest.TestCase):
+    def test_title_and_body(self):
+        class Doc:
+            rel = "docs/superpowers/plans/2026-01-01-feature-x.md"
+        row = _row(Doc.rel, "partial", 2, 5)
+        missing = [DeclaredPath("create", "src/a.ts"), DeclaredPath("modify", "src/b.ts")]
+        title, body = issue_for(Doc(), row, missing)
+        self.assertIn("2026-01-01-feature-x", title)
+        self.assertIn("2/5", body)
+        self.assertIn("`src/a.ts`", body)
+        self.assertIn("`src/b.ts`", body)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_reconcile_readonly.py

@@ -0,0 +1,239 @@
+"""Read-only GitHub contract test for the reconcile subcommand.
+
+The docstring at the top of commands/reconcile.py declares:
+  "reconcile only READS GitHub via `gh issue list`. It NEVER writes labels,
+   edits issues, or modifies remote state."
+
+This test enforces that contract. Without it, the docstring is aspirational —
+a future refactor could silently introduce a `gh issue edit` (or close, or
+label, or comment) call and the existing test suite would still pass.
+
+The test mocks subprocess.run, drives reconcile against a fake track, and
+asserts every captured `gh` invocation matches an allowlist of read-only
+verbs. It exercises both the default-label path (no `github.labels`
+override) and the new override path from #32.
+"""
+import json
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import reconcile
+
+# Allowlist of `gh` subcommand pairs considered read-only.
+# `gh api` is intentionally excluded — it can be GET or write depending on -X.
+# If reconcile ever needs it, add a more specific check (require -X GET, etc.).
+READ_ONLY_GH_VERBS = {
+    ("issue", "list"),
+    ("issue", "view"),
+    ("pr", "list"),
+    ("pr", "view"),
+}
+
+
+def _fake_track(*, slug, repo, labels=None, issues=None):
+    meta = {
+        "track": slug,
+        "status": "active",
+        "github": {"repo": repo, "issues": issues or []},
+    }
+    if labels is not None:
+        meta["github"]["labels"] = labels
+    return SimpleNamespace(
+        name=slug,
+        path=Path(f"/tmp/fake/{slug}.md"),
+        body="# fake",
+        meta=meta,
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class ReadOnlyContractTest(unittest.TestCase):
+    def _drive(self, *, track, gh_response, user_choice, extra_args=None):
+        """Run reconcile.run against mocks; return (exit_code, captured_argvs, write_mock, prompt_mock)."""
+        captured = []
+
+        def fake_run(argv, *args, **kwargs):
+            captured.append(list(argv))
+            return MagicMock(returncode=0, stdout=json.dumps(gh_response), stderr="")
+
+        cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/ok"}}}
+        # NOTE: find_track_by_name is intentionally NOT mocked. We let the real
+        # resolver run against the in-memory [track] list so a regression that
+        # broke the active-status filter (or the name-matching logic) would
+        # surface here — not just be silently bypassed by the mock.
+        with patch("commands.reconcile.subprocess.run", side_effect=fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks", return_value=[track]), \
+             patch("commands.reconcile.prompt_input", return_value=user_choice) as mock_prompt, \
+             patch("commands.reconcile.write_file") as mock_write:
+            args = [track.meta["track"]] + (extra_args or [])
+            rc = reconcile.run(args)
+        return rc, captured, mock_write, mock_prompt
+
+    def _assert_read_only(self, captured):
+        gh_calls = [a for a in captured if a and a[0] == "gh"]
+        self.assertGreater(len(gh_calls), 0,
+                           "reconcile should have made at least one gh call")
+        for argv in gh_calls:
+            verb_pair = tuple(argv[1:3])
+            self.assertIn(
+                verb_pair, READ_ONLY_GH_VERBS,
+                f"reconcile invoked a non-read-only gh command: {' '.join(argv)}\n"
+                f"This violates the READ-ONLY GITHUB CONTRACT documented at the top "
+                f"of commands/reconcile.py. Writes must go through the local "
+                f"frontmatter file, never through gh.",
+            )
+
+    def test_default_label_path_is_read_only(self):
+        # Track without `github.labels` falls back to default `track/<slug>`.
+        track = _fake_track(slug="alpha", repo="ok/ok", labels=None, issues=[1, 2, 3])
+        gh_response = [
+            {"number": 1, "title": "one", "state": "OPEN"},
+            {"number": 4, "title": "four", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, _ = self._drive(
+            track=track, gh_response=gh_response, user_choice="n",
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_write.assert_not_called()
+
+    def test_label_override_path_is_read_only(self):
+        # Track WITH `github.labels` override (the new feature from #32).
+        # Each label produces a `gh issue list` AND a `gh pr list` — all must
+        # be read-only. PRs are queried so frontmatter entries pointing at
+        # labeled PRs aren't spuriously FLAGged.
+        track = _fake_track(slug="beta", repo="ok/ok",
+                            labels=["storytelling", "campaigns"], issues=[10])
+        gh_response = [{"number": 10, "title": "x", "state": "OPEN"}]
+        rc, captured, mock_write, _ = self._drive(
+            track=track, gh_response=gh_response, user_choice="n",
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        # Two configured labels × two kinds (issue + pr) → four gh invocations
+        gh_calls = [a for a in captured if a and a[0] == "gh"]
+        self.assertEqual(len(gh_calls), 4,
+                         f"expected one gh issue + one gh pr call per label, got {len(gh_calls)}")
+        kinds = sorted(c[1] for c in gh_calls)
+        self.assertEqual(kinds, ["issue", "issue", "pr", "pr"],
+                         f"expected two issue + two pr calls, got {kinds}")
+
+    def test_user_accept_writes_local_file_only_not_gh(self):
+        # Even when the user accepts the proposed ADDs, the only write should
+        # be to the local frontmatter file via write_file — never via gh.
+        track = _fake_track(slug="gamma", repo="ok/ok", issues=[5])
+        gh_response = [
+            {"number": 5, "title": "x", "state": "OPEN"},
+            {"number": 99, "title": "new", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, _ = self._drive(
+            track=track, gh_response=gh_response, user_choice="y",
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_write.assert_called_once()
+
+    def test_draft_skips_user_prompt_and_write(self):
+        # --draft prints the analysis but never prompts and never writes.
+        # Even with proposed ADDs (so the report path is exercised), the user
+        # should not be interrupted and the local file should remain untouched.
+        # user_choice="y" would normally trigger a write — proves --draft
+        # short-circuits before the prompt is reached.
+        track = _fake_track(slug="delta", repo="ok/ok", issues=[5])
+        gh_response = [
+            {"number": 5, "title": "x", "state": "OPEN"},
+            {"number": 99, "title": "new", "state": "OPEN"},
+        ]
+        rc, captured, mock_write, mock_prompt = self._drive(
+            track=track, gh_response=gh_response,
+            user_choice="y", extra_args=["--draft"],
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_prompt.assert_not_called()
+        mock_write.assert_not_called()
+
+
+    def test_timeout_skips_track_but_continues_others(self):
+        # When _fetch_labeled_issues raises TimeoutExpired for one track, the
+        # track is skipped with a ⚠ warning and the rest of --all continues.
+        # Verifies: no crash, warning printed, other tracks still processed.
+        track_alpha = _fake_track(slug="alpha", repo="ok/ok", issues=[1])
+        track_beta = _fake_track(slug="beta", repo="ok/ok", issues=[10])
+
+        captured = []
+        timed_out_labels = set()
+
+        def fake_run(argv, *args, **kwargs):
+            captured.append(list(argv))
+            # alpha's default label is "track/alpha" — time it out
+            if "--label" in argv:
+                label_idx = argv.index("--label") + 1
+                label = argv[label_idx]
+                if label == "track/alpha":
+                    timed_out_labels.add(label)
+                    raise subprocess.TimeoutExpired(cmd=argv, timeout=15)
+            return MagicMock(
+                returncode=0,
+                stdout=json.dumps([{"number": 10, "title": "x", "state": "OPEN"}]),
+                stderr="",
+            )
+
+        cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/ok"}}}
+        with patch("commands.reconcile.subprocess.run", side_effect=fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks",
+                   return_value=[track_alpha, track_beta]), \
+             patch("commands.reconcile.prompt_input",
+                   return_value="n") as mock_prompt, \
+             patch("commands.reconcile.write_file") as mock_write:
+            rc = reconcile.run(["--all"])
+
+        self.assertEqual(rc, 0)
+        self.assertTrue(timed_out_labels, "alpha label should have timed out")
+        # Beta's gh calls should have succeeded
+        beta_calls = [a for a in captured
+                      if "--label" in a and a[a.index("--label") + 1] == "track/beta"]
+        self.assertTrue(len(beta_calls) > 0,
+                        "beta should have been fetched after alpha timeout")
+        mock_write.assert_not_called()
+
+    def test_single_track_timeout_skips_cleanly(self):
+        # Even with a single track (the non-parallel code path), a timeout
+        # should skip the track with a warning and return 0 without crashing.
+        track = _fake_track(slug="lonely", repo="ok/ok", issues=[7])
+
+        captured = []
+        timed_out = False
+
+        def fake_run(argv, *args, **kwargs):
+            captured.append(list(argv))
+            nonlocal timed_out
+            timed_out = True
+            raise subprocess.TimeoutExpired(cmd=argv, timeout=15)
+
+        cfg = {"notes_root": "/tmp/fake-notes", "repos": {"ok": {"github": "ok/ok"}}}
+        with patch("commands.reconcile.subprocess.run", side_effect=fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks", return_value=[track]), \
+             patch("commands.reconcile.prompt_input") as mock_prompt, \
+             patch("commands.reconcile.write_file") as mock_write:
+            rc = reconcile.run(["lonely"])
+
+        self.assertEqual(rc, 0)
+        self.assertTrue(timed_out)
+        mock_prompt.assert_not_called()
+        mock_write.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_reconcile_wrappers.py

@@ -0,0 +1,55 @@
+"""Tests for git_mv + create_issue (mock subprocess; offline)."""
+import unittest
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from unittest import mock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib import git_state, github_state
+
+
+class GitMvTest(unittest.TestCase):
+    def test_creates_dest_dir_and_calls_git_mv(self):
+        calls = {}
+
+        def fake_run(cmd, **kw):
+            calls["cmd"] = cmd
+            return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+        with mock.patch("lib.git_state.subprocess.run", side_effect=fake_run), \
+             mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state.Path.mkdir") as mkdir:
+            ok = git_state.git_mv("a/x.md", "a/archive/abandoned/x.md", Path("/repo"))
+        self.assertTrue(ok)
+        self.assertIn("mv", calls["cmd"])
+        self.assertIn("a/x.md", calls["cmd"])
+        self.assertIn("a/archive/abandoned/x.md", calls["cmd"])
+        mkdir.assert_called()
+
+    def test_returns_false_on_git_error(self):
+        fake = SimpleNamespace(returncode=1, stdout="", stderr="not under version control")
+        with mock.patch("lib.git_state.subprocess.run", return_value=fake), \
+             mock.patch("lib.git_state.Path.exists", return_value=True), \
+             mock.patch("lib.git_state.Path.mkdir"):
+            self.assertFalse(git_state.git_mv("a.md", "b.md", Path("/repo")))
+
+
+class CreateIssueTest(unittest.TestCase):
+    def test_returns_url_on_success(self):
+        fake = SimpleNamespace(returncode=0,
+                               stdout="https://github.com/o/r/issues/42\n", stderr="")
+        with mock.patch("lib.github_state.subprocess.run", return_value=fake):
+            url = github_state.create_issue("o/r", "Finish plan: x", "body")
+        self.assertEqual(url, "https://github.com/o/r/issues/42")
+
+    def test_returns_none_on_failure(self):
+        fake = SimpleNamespace(returncode=1, stdout="", stderr="gh: error")
+        with mock.patch("lib.github_state.subprocess.run", return_value=fake):
+            self.assertIsNone(github_state.create_issue("o/r", "t", "b"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_refresh_md.py

@@ -0,0 +1,98 @@
+"""Tests for refresh-md row-append behavior (issue #77).
+
+Before #77, refresh-md only rewrote the *status cell* of rows already in the
+canonical table — it never appended rows for issues present in frontmatter but
+missing from the table, yet still printed "All tracks in sync." These tests
+pin the membership-aware behavior: missing frontmatter issues get appended in
+frontmatter order, and the "in sync" message only prints when nothing changed.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import refresh_md
+from lib.status_table import find_canonical_status_tables, ISSUE_NUM_RE
+
+CANON_HEADER = (
+    "## Issues (canonical)\n\n"
+    "<!-- canonical-issue-table — auto-managed. -->\n\n"
+    "| # | Title | Assignee | Status |\n"
+    "|---|---|---|---|\n"
+)
+
+
+def _track(*, name, repo, issues, rows):
+    body = CANON_HEADER + "\n".join(rows) + "\n\n---\n\n## Notes\n\nnarrative\n"
+    return SimpleNamespace(
+        name=name,
+        path=Path(f"/tmp/fake/{name}.md"),
+        body=body,
+        meta={"track": name, "status": "active",
+              "github": {"repo": repo, "issues": list(issues)}},
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+def _issue(num, title, state="OPEN", logins=()):
+    return {"number": num, "title": title, "state": state,
+            "assignees": [{"login": l} for l in logins]}
+
+
+class RefreshAppendTest(unittest.TestCase):
+    def _drive(self, track, issues, args):
+        cfg = {"notes_root": "/tmp/fake"}
+        with patch("commands.refresh_md.load_config", return_value=cfg), \
+             patch("commands.refresh_md.discover_tracks", return_value=[track]), \
+             patch("commands.refresh_md.fetch_issues", return_value=issues), \
+             patch("commands.refresh_md.write_file") as mw:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = refresh_md.run(args)
+        return rc, mw, buf.getvalue()
+
+    def test_appends_missing_rows_in_frontmatter_order(self):
+        track = _track(
+            name="platform-health", repo="o/r",
+            issues=[1, 2, 30, 40],  # 30, 40 newly slotted, not yet in table
+            rows=["| #1 | first | — | 🔲 Open |",
+                  "| #2 | second | — | ✅ Shipped |"],
+        )
+        issues = [_issue(1, "first"), _issue(2, "second", "CLOSED"),
+                  _issue(30, "third", "OPEN", ["bob"]), _issue(40, "fourth", "CLOSED")]
+        rc, mw, out = self._drive(track, issues, ["platform-health", "--yes"])
+
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        new_body = mw.call_args[0][2]
+        table = find_canonical_status_tables(new_body)[0]
+        nums = [int(ISSUE_NUM_RE.search(r["cells"][0]).group(1)) for r in table["rows"]]
+        self.assertEqual(nums, [1, 2, 30, 40])
+        self.assertIn("| #30 | third | @bob | 🔲 Open |", new_body)
+        self.assertIn("| #40 | fourth | — | ✅ Shipped |", new_body)
+        self.assertNotIn("All tracks in sync.", out)
+        self.assertIn("row", out.lower())
+
+    def test_no_drift_reports_in_sync(self):
+        track = _track(
+            name="steady", repo="o/r", issues=[1, 2],
+            rows=["| #1 | first | — | 🔲 Open |",
+                  "| #2 | second | — | ✅ Shipped |"],
+        )
+        issues = [_issue(1, "first"), _issue(2, "second", "CLOSED")]
+        rc, mw, out = self._drive(track, issues, ["steady", "--yes"])
+
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        self.assertIn("All tracks in sync.", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/tests/test_render.py

@@ -0,0 +1,110 @@
+"""Tests for render module."""
+import unittest
+import sys
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.render import time_aware_framing, render_track_row
+
+
+class TimeAwareFramingTest(unittest.TestCase):
+    def test_long_gap(self):
+        self.assertIn("Fresh start", time_aware_framing(7 * 3600, 14))
+
+    def test_morning_says_fresh_start(self):
+        self.assertIn("Fresh start", time_aware_framing(1800, 9))
+
+    def test_medium_gap(self):
+        self.assertIn("Picking back up", time_aware_framing(2 * 3600, 14))
+
+    def test_short_gap(self):
+        self.assertIn("Continuing", time_aware_framing(30 * 60, 14))
+
+    def test_late_night_handoff_nudge(self):
+        f = time_aware_framing(1800, 23, handoff_today=False)
+        self.assertIn("handoff", f.lower())
+
+
+class RenderTrackRowTest(unittest.TestCase):
+    def _data(self, **overrides):
+        d = {
+            "name": "tabletop", "operational_status": "active",
+            "launch_priority": "P1", "milestone_alignment": "v1.0.0",
+            "last_touched_label": "5d ago", "last_handoff_label": "5d ago",
+            "next_up": [], "active_branches": [], "new_issues": [],
+            "blockers": [], "drift_items": [], "closure_ready": False,
+            "closure_signals_summary": None, "archived_reopen": [],
+        }
+        d.update(overrides); return d
+
+    def test_basic_row(self):
+        row = render_track_row(self._data())
+        for s in ["tabletop", "P1", "v1.0.0", "5d ago"]:
+            self.assertIn(s, row)
+
+    def test_in_progress_badge(self):
+        self.assertIn("in-progress", render_track_row(self._data(operational_status="in-progress")))
+
+    def test_active_branch_shown(self):
+        row = render_track_row(self._data(
+            active_branches=[{"name": "feat/4254", "ahead": 1, "uncommitted_files": 2}]
+        ))
+        self.assertIn("feat/4254", row)
+        self.assertIn("ahead 1", row)
+
+    def test_new_issues_shown(self):
+        row = render_track_row(self._data(new_issues=[{"number": 9, "title": "new"}]))
+        self.assertIn("#9", row)
+        self.assertIn("slot 9", row)
+
+    def test_drift_shown(self):
+        row = render_track_row(self._data(
+            drift_items=[{"issue": 1, "body_status": "open", "github_state": "CLOSED"}]
+        ))
+        self.assertIn("Drift:", row)
+        self.assertIn("#1", row)
+
+    def test_closure_ready_shown(self):
+        self.assertIn("Closure?:   YES", render_track_row(self._data(closure_ready=True)))
+
+    def test_empty_next_up_default_message(self):
+        row = render_track_row(self._data(next_up=[]))
+        self.assertIn("<empty — set 'next_up:'", row)
+
+    def test_next_up_all_closed_message(self):
+        row = render_track_row(self._data(
+            next_up=[],
+            next_up_stale_closed_count=2,
+            track_slug="ux-redesign",
+        ))
+        self.assertIn("all 2 items have shipped", row)
+        self.assertIn("/work-plan handoff ux-redesign", row)
+
+    def test_next_up_single_closed_uses_singular(self):
+        row = render_track_row(self._data(
+            next_up=[],
+            next_up_stale_closed_count=1,
+            track_slug="ux-redesign",
+        ))
+        self.assertIn("all 1 item has shipped", row)
+
+    def test_next_up_includes_milestone_when_present(self):
+        row = render_track_row(self._data(next_up=[
+            {"number": 4155, "title": "Armory batch multi-select",
+             "priority": "P3", "state": "open", "milestone": "v0.4.0"},
+        ]))
+        self.assertIn("(P3, open, v0.4.0)", row)
+
+    def test_next_up_omits_milestone_when_absent(self):
+        row = render_track_row(self._data(next_up=[
+            {"number": 4155, "title": "Armory batch multi-select",
+             "priority": "P3", "state": "open", "milestone": ""},
+        ]))
+        self.assertIn("(P3, open)", row)
+        self.assertNotIn("(P3, open, ", row)
+
+
+if __name__ == "__main__":
+    unittest.main()