@stylusnexus/work-plan 2026.6.10 → 2026.6.11

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

@@ -0,0 +1,312 @@
+"""Tests for the notes-vcs command + the dispatcher auto-commit hook (#103).
+
+All git and yq calls are mocked — offline, no real repo touched.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout, redirect_stderr
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+import work_plan
+from commands import notes_vcs as cmd
+
+
+def _cfg(notes_root="/tmp/notes", auto=None):
+    c = {"notes_root": notes_root, "repos": {}}
+    if auto is not None:
+        c["notes_vcs"] = {"auto_commit": auto}
+    return c
+
+
+def _drive(args, *, cfg=None, is_root=False, is_under=False,
+           last="ab12 subject", set_ok=True, init_ok=True, dirty=False,
+           sha="ab12", revert_sha="rev99", remotes=False, owned=True,
+           parent=None):
+    cfg = cfg or _cfg()
+    with patch("commands.notes_vcs.load_config", return_value=cfg), \
+         patch("commands.notes_vcs.notes_vcs.is_git_root", return_value=is_root), \
+         patch("commands.notes_vcs.notes_vcs.is_under_git", return_value=is_under), \
+         patch("commands.notes_vcs.notes_vcs.has_remotes", return_value=remotes), \
+         patch("commands.notes_vcs.notes_vcs.is_owned", return_value=owned), \
+         patch("commands.notes_vcs.notes_vcs.last_commit_summary", return_value=last), \
+         patch("commands.notes_vcs.notes_vcs.last_commit_sha", return_value=sha), \
+         patch("commands.notes_vcs.notes_vcs.head_parent_sha", return_value=parent), \
+         patch("commands.notes_vcs.notes_vcs.has_changes", return_value=dirty), \
+         patch("commands.notes_vcs.notes_vcs.init_repo", return_value=init_ok), \
+         patch("commands.notes_vcs.notes_vcs.revert", return_value=revert_sha) as mrev, \
+         patch("commands.notes_vcs._set_auto_commit", return_value=set_ok) as mset:
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = cmd.run(args)
+    return rc, buf.getvalue(), mset, mrev
+
+
+class NotesVcsStatusTest(unittest.TestCase):
+    def test_status_repo_on(self):
+        rc, out, _, _ = _drive(["status"], cfg=_cfg(auto=True), is_root=True)
+        self.assertEqual(rc, 0)
+        self.assertIn("local repo", out)
+        self.assertIn("auto-commit: on", out)
+
+    def test_status_not_a_repo(self):
+        rc, out, _, _ = _drive(["status"], cfg=_cfg(auto=False), is_root=False)
+        self.assertEqual(rc, 0)
+        self.assertIn("not a repo", out)
+        self.assertIn("auto-commit: off", out)
+
+    def test_status_inside_other_repo(self):
+        rc, out, _, _ = _drive(["status"], is_root=False, is_under=True)
+        self.assertEqual(rc, 0)
+        self.assertIn("NOT its root", out)
+
+    def test_default_action_is_status(self):
+        rc, out, _, _ = _drive([], is_root=True)
+        self.assertEqual(rc, 0)
+        self.assertIn("notes_root:", out)
+
+
+class NotesVcsInitTest(unittest.TestCase):
+    def test_init_enables_by_default(self):
+        rc, out, mset, _ = _drive(["init"], is_root=False, is_under=False)
+        self.assertEqual(rc, 0)
+        self.assertIn("Initialized local history", out)
+        mset.assert_called_once_with(True)
+        self.assertIn("auto-commit enabled", out)
+
+    def test_init_no_enable_skips_toggle(self):
+        rc, out, mset, _ = _drive(["init", "--no-enable"], is_root=False)
+        self.assertEqual(rc, 0)
+        mset.assert_not_called()
+        self.assertIn("left off", out)
+
+    def test_init_refuses_inside_other_repo(self):
+        rc, out, mset, _ = _drive(["init"], is_root=False, is_under=True)
+        self.assertEqual(rc, 1)
+        self.assertIn("not its root", out.lower())
+        mset.assert_not_called()
+
+    def test_init_fails_when_init_repo_fails(self):
+        rc, out, mset, _ = _drive(["init"], is_root=False, is_under=False, init_ok=False)
+        self.assertEqual(rc, 1)
+        self.assertIn("failed to git-init", out)
+
+    def test_init_refuses_existing_repo_with_remote(self):
+        # An existing repo with a remote must be rejected — private notes must
+        # never be pushable (Codex high #1).
+        rc, out, mset, _ = _drive(["init"], is_root=True, remotes=True)
+        self.assertEqual(rc, 1)
+        self.assertIn("remote", out.lower())
+        mset.assert_not_called()
+
+    def test_init_refuses_existing_unowned_repo(self):
+        # An existing repo work-plan didn't create must not be adopted.
+        rc, out, mset, _ = _drive(["init"], is_root=True, remotes=False, owned=False)
+        self.assertEqual(rc, 1)
+        self.assertIn("not created by work-plan", out)
+        mset.assert_not_called()
+
+
+class NotesVcsToggleTest(unittest.TestCase):
+    def test_enable(self):
+        rc, out, mset, _ = _drive(["enable"], is_root=True)
+        self.assertEqual(rc, 0)
+        mset.assert_called_once_with(True)
+
+    def test_enable_warns_when_not_repo(self):
+        rc, out, mset, _ = _drive(["enable"], is_root=False)
+        self.assertEqual(rc, 0)
+        self.assertIn("WARN", out)
+
+    def test_disable(self):
+        rc, out, mset, _ = _drive(["disable"], is_root=True)
+        self.assertEqual(rc, 0)
+        mset.assert_called_once_with(False)
+
+    def test_unknown_action_rc2(self):
+        rc, out, _, _ = _drive(["frobnicate"])
+        self.assertEqual(rc, 2)
+        self.assertIn("usage", out.lower())
+
+
+class NotesVcsStatusJsonTest(unittest.TestCase):
+    def test_json_shape(self):
+        import json
+        rc, out, _, _ = _drive(["status", "--json"], cfg=_cfg(auto=True),
+                               is_root=True, is_under=True, sha="ab12",
+                               last="ab12 subject", dirty=False, parent="pa01")
+        self.assertEqual(rc, 0)
+        blob = json.loads(out)
+        self.assertEqual(blob["auto_commit"], True)
+        self.assertEqual(blob["is_root"], True)
+        self.assertEqual(blob["under_git"], True)
+        self.assertEqual(blob["last_commit_sha"], "ab12")
+        self.assertEqual(blob["head_parent_sha"], "pa01")
+        self.assertEqual(blob["dirty"], False)
+
+    def test_json_nulls_when_not_repo(self):
+        import json
+        rc, out, _, _ = _drive(["status", "--json"], cfg=_cfg(auto=False),
+                               is_root=False, is_under=False)
+        blob = json.loads(out)
+        self.assertEqual(blob["is_root"], False)
+        self.assertIsNone(blob["last_commit_sha"])
+        self.assertEqual(blob["auto_commit"], False)
+
+
+class NotesVcsUndoTest(unittest.TestCase):
+    def test_undo_head_default(self):
+        rc, out, _, mrev = _drive(["undo"], is_root=True, revert_sha="rev99")
+        self.assertEqual(rc, 0)
+        mrev.assert_called_once()
+        # default sha is None → revert(notes_root, None)
+        self.assertIsNone(mrev.call_args[0][1])
+        self.assertIn("rev99", out)
+
+    def test_undo_named_sha(self):
+        rc, out, _, mrev = _drive(["undo", "abc1234"], is_root=True,
+                                  revert_sha="rev88")
+        self.assertEqual(rc, 0)
+        self.assertEqual(mrev.call_args[0][1], "abc1234")
+
+    def test_undo_refuses_when_not_repo(self):
+        rc, out, _, mrev = _drive(["undo"], is_root=False)
+        self.assertEqual(rc, 1)
+        mrev.assert_not_called()
+        self.assertIn("not a git repo", out)
+
+    def test_undo_refuses_remote_backed_repo(self):
+        rc, out, _, mrev = _drive(["undo"], is_root=True, remotes=True)
+        self.assertEqual(rc, 1)
+        mrev.assert_not_called()
+        self.assertIn("local-history repo", out)
+
+    def test_undo_refuses_unowned_repo(self):
+        rc, out, _, mrev = _drive(["undo"], is_root=True, remotes=False, owned=False)
+        self.assertEqual(rc, 1)
+        mrev.assert_not_called()
+        self.assertIn("local-history repo", out)
+
+    def test_undo_fails_when_revert_fails(self):
+        rc, out, _, mrev = _drive(["undo"], is_root=True, revert_sha=None)
+        self.assertEqual(rc, 1)
+        self.assertIn("failed to revert", out)
+
+
+class RegistrationTest(unittest.TestCase):
+    def test_in_subcommands(self):
+        self.assertEqual(work_plan.SUBCOMMANDS["notes-vcs"], "commands.notes_vcs")
+
+    def test_in_descriptions(self):
+        names = [e[0] for e in work_plan.DESCRIPTIONS]
+        self.assertIn("notes-vcs", names)
+
+
+class DispatcherHookTest(unittest.TestCase):
+    """The two-phase auto-commit hook: snapshot dirty paths BEFORE the command
+    (_notes_precommit_state), then commit ONLY the paths it changed
+    (_commit_changed_notes). Gated on opt-in + owned + no-remote; never raises.
+    """
+
+    def _run_dispatch(self, sub, parts, *, cfg, is_root=True, is_under=False,
+                      owned=True, remotes=False, before=None, after=None,
+                      sha="c0ffee"):
+        before = set() if before is None else set(before)
+        after = before if after is None else set(after)
+        dirty_seq = [before, after]
+        with patch("lib.config.load_config", return_value=cfg), \
+             patch("lib.notes_vcs.is_git_root", return_value=is_root), \
+             patch("lib.notes_vcs.is_under_git", return_value=is_under), \
+             patch("lib.notes_vcs.is_owned", return_value=owned), \
+             patch("lib.notes_vcs.has_remotes", return_value=remotes), \
+             patch("lib.notes_vcs.dirty_paths", side_effect=lambda _r: dirty_seq.pop(0)), \
+             patch("lib.notes_vcs.auto_commit", return_value=sha) as mac:
+            err = io.StringIO()
+            with redirect_stderr(err):
+                pre = work_plan._notes_precommit_state(sub)
+                if pre is not None:
+                    work_plan._commit_changed_notes(pre, parts)
+            return err.getvalue(), mac, pre
+
+    def test_commits_only_paths_changed_by_the_command(self):
+        out, mac, pre = self._run_dispatch(
+            "slot", ["slot", "103", "tabletop"], cfg=_cfg(auto=True),
+            before=set(), after={"tabletop.md"})
+        self.assertIsNotNone(pre)
+        mac.assert_called_once()
+        self.assertEqual(mac.call_args[0][1], "work-plan slot 103 tabletop")
+        self.assertEqual(mac.call_args[1]["paths"], ["tabletop.md"])
+        self.assertIn("committed c0ffee", out)
+
+    def test_preserves_preexisting_dirty_files(self):
+        # A file dirty BEFORE the command stays out of the commit.
+        out, mac, _ = self._run_dispatch(
+            "slot", ["slot", "1", "t"], cfg=_cfg(auto=True),
+            before={"manual.md"}, after={"manual.md", "t.md"})
+        mac.assert_called_once()
+        self.assertEqual(mac.call_args[1]["paths"], ["t.md"])
+
+    def test_noop_when_command_changed_nothing(self):
+        out, mac, _ = self._run_dispatch(
+            "slot", ["slot", "1", "t"], cfg=_cfg(auto=True),
+            before={"manual.md"}, after={"manual.md"})
+        mac.assert_not_called()
+
+    def test_skips_read_only_command(self):
+        out, mac, pre = self._run_dispatch(
+            "brief", ["brief"], cfg=_cfg(auto=True), after={"x.md"})
+        self.assertIsNone(pre)
+        mac.assert_not_called()
+
+    def test_skips_read_only_flag_alias(self):
+        out, mac, pre = self._run_dispatch(
+            "--brief", ["--brief"], cfg=_cfg(auto=True), after={"x.md"})
+        self.assertIsNone(pre)
+        mac.assert_not_called()
+
+    def test_skips_when_disabled(self):
+        out, mac, pre = self._run_dispatch(
+            "slot", ["slot", "1", "t"], cfg=_cfg(auto=False), after={"x.md"})
+        self.assertIsNone(pre)
+        mac.assert_not_called()
+
+    def test_skips_when_unowned(self):
+        out, mac, pre = self._run_dispatch(
+            "slot", ["slot", "1", "t"], cfg=_cfg(auto=True), owned=False,
+            after={"x.md"})
+        self.assertIsNone(pre)
+        mac.assert_not_called()
+
+    def test_skips_when_remote_backed(self):
+        out, mac, pre = self._run_dispatch(
+            "slot", ["slot", "1", "t"], cfg=_cfg(auto=True), remotes=True,
+            after={"x.md"})
+        self.assertIsNone(pre)
+        mac.assert_not_called()
+
+    def test_nudges_when_enabled_but_not_repo(self):
+        out, mac, pre = self._run_dispatch(
+            "slot", ["slot", "1", "t"], cfg=_cfg(auto=True), is_root=False,
+            is_under=False, after={"x.md"})
+        self.assertIsNone(pre)
+        mac.assert_not_called()
+        self.assertIn("notes-vcs init", out)
+
+    def test_skips_self(self):
+        # notes-vcs manages its own repo; the hook must not double-commit.
+        with patch("lib.config.load_config") as mload:
+            pre = work_plan._notes_precommit_state("notes-vcs")
+            self.assertIsNone(pre)
+            mload.assert_not_called()
+
+    def test_precommit_never_raises_on_failure(self):
+        with patch("lib.config.load_config", side_effect=RuntimeError("boom")):
+            self.assertIsNone(work_plan._notes_precommit_state("slot"))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -41,7 +41,7 @@ class IssuesTest(unittest.TestCase):
     def test_draft_previews_without_creating(self):
         with tempfile.TemporaryDirectory() as d:
             root = self._repo(d)
-            rc, out, ci = self._run(root, ["--issues", "--draft", "--repo=critforge"])
+            rc, out, ci = self._run(root, ["--issues", "--draft", "--repo=myproject"])
             self.assertEqual(rc, 0)
             self.assertIn("gone.ts", out)       # unsatisfied path shown in preview
             ci.assert_not_called()
@@ -49,7 +49,7 @@ class IssuesTest(unittest.TestCase):
     def test_apply_creates_issue_after_confirm(self):
         with tempfile.TemporaryDirectory() as d:
             root = self._repo(d)
-            rc, out, ci = self._run(root, ["--issues", "--repo=critforge"])
+            rc, out, ci = self._run(root, ["--issues", "--repo=myproject"])
             self.assertEqual(rc, 0)
             ci.assert_called_once()
             title, body = ci.call_args[0][1], ci.call_args[0][2]

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

@@ -1,10 +1,11 @@
-"""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.
+"""Tests for refresh-md.
+
+Canonical tables are RE-DERIVED on every run from frontmatter membership + live
+GitHub data, milestone-ordered via the shared renderer (#101). This makes the
+markdown table self-healing: order, the Milestone column, missing rows, and
+statuses are all rebuilt each run, so it can't decay or drift from the viewer.
+Tracks WITHOUT a canonical table keep the conservative in-place behavior
+(update status cells, append missing rows in frontmatter order — issue #77).
 """
 import io
 import sys
@@ -12,86 +13,183 @@ import unittest
 from contextlib import redirect_stdout
 from pathlib import Path
 from types import SimpleNamespace
-from unittest.mock import MagicMock, patch
+from unittest.mock import 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"
+from lib.status_table import (
+    find_canonical_status_tables, render_canonical_table, ISSUE_NUM_RE,
 )
 
 
-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 _gh(num, title, state="OPEN", logins=(), milestone=None):
+    """A gh-issue dict as fetch_issues returns."""
+    d = {"number": num, "title": title, "state": state,
+         "assignees": [{"login": l} for l in logins]}
+    if milestone:
+        d["milestone"] = {"title": milestone}
+    return d
 
 
-def _issue(num, title, state="OPEN", logins=()):
-    return {"number": num, "title": title, "state": state,
-            "assignees": [{"login": l} for l in logins]}
+def _canon_body(ghs, milestone_alignment=None, *, trailing="## Notes\n\nnarrative\n"):
+    """Build a track body whose canonical block is exactly what
+    render_canonical_table would emit for `ghs` — so re-derive round-trips."""
+    by = {g["number"]: g for g in ghs}
+    nums = [g["number"] for g in ghs]
+    table = render_canonical_table(nums, by, milestone_alignment)
+    return table + "\n---\n\n" + trailing
 
 
-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 _track(*, name, repo, issues, body, milestone_alignment=None):
+    meta = {"track": name, "status": "active",
+            "github": {"repo": repo, "issues": list(issues)}}
+    if milestone_alignment:
+        meta["milestone_alignment"] = milestone_alignment
+    return SimpleNamespace(
+        name=name, path=Path(f"/tmp/fake/{name}.md"), body=body, meta=meta,
+        has_frontmatter=True, repo=repo,
+    )
 
-    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"])
+
+def _drive(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()
+
+
+class CanonicalRederiveTest(unittest.TestCase):
+    def test_missing_frontmatter_issues_appear_after_rederive(self):
+        """Issues in frontmatter but absent from the table show up after refresh
+        (membership is frontmatter-canonical); table is the new 5-col form."""
+        existing = [_gh(1, "first"), _gh(2, "second", "CLOSED")]
+        track = _track(name="platform-health", repo="o/r",
+                       issues=[1, 2, 30, 40], body=_canon_body(existing))
+        fetched = existing + [_gh(30, "third", "OPEN", ["bob"]),
+                              _gh(40, "fourth", "CLOSED")]
+        rc, mw, out = _drive(track, fetched, ["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"]]
+        nums = [int(ISSUE_NUM_RE.search(r["cells"][0]).group(1))
+                for r in table["rows"] if ISSUE_NUM_RE.search(r["cells"][0])]
         self.assertEqual(nums, [1, 2, 30, 40])
-        self.assertIn("| #30 | third | @bob | 🔲 Open |", new_body)
-        self.assertIn("| #40 | fourth | — | ✅ Shipped |", new_body)
+        # New 5-column form: # | Title | Milestone | Assignee | Status
+        self.assertIn("| # | Title | Milestone | Assignee | Status |", new_body)
+        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):
+        """A canonical block already identical to what render produces → no
+        write, 'in sync'. Fixture built from the shared renderer round-trips."""
+        ghs = [_gh(1, "first"), _gh(2, "second", "CLOSED")]
+        track = _track(name="steady", repo="o/r", issues=[1, 2],
+                       body=_canon_body(ghs))
+        rc, mw, out = _drive(track, ghs, ["steady", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_not_called()
+        self.assertIn("All tracks in sync.", out)
+
+    def test_status_change_is_rewritten(self):
+        """An issue that closed since last refresh gets its status corrected."""
+        ghs_old = [_gh(1, "first", "OPEN")]
+        track = _track(name="t", repo="o/r", issues=[1], body=_canon_body(ghs_old))
+        rc, mw, out = _drive(track, [_gh(1, "first", "CLOSED")], ["t", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertIn("| #1 | first |  | — | ✅ Shipped |", mw.call_args[0][2])
+
+    def test_rederive_orders_active_milestone_first(self):
+        """Re-derive groups + orders issues active-milestone-first, even when
+        the existing table was in plain numeric order."""
+        # Existing table: numeric order, no milestone awareness.
+        stale = [_gh(10, "near"), _gh(20, "far"), _gh(30, "someday")]
         track = _track(
-            name="steady", repo="o/r", issues=[1, 2],
-            rows=["| #1 | first | — | 🔲 Open |",
-                  "| #2 | second | — | ✅ Shipped |"],
+            name="mixed", repo="o/r", issues=[10, 20, 30],
+            body=_canon_body(stale), milestone_alignment="v2.0.0",
         )
-        issues = [_issue(1, "first"), _issue(2, "second", "CLOSED")]
-        rc, mw, out = self._drive(track, issues, ["steady", "--yes"])
+        # Live data: #20 is the active milestone (v2.0.0), #10 is future, #30 none.
+        fetched = [
+            _gh(10, "near", milestone="v0.4.0 — MVP"),
+            _gh(20, "far", milestone="v2.0.0 — Post-Launch"),
+            _gh(30, "someday"),
+        ]
+        rc, mw, out = _drive(track, fetched, ["mixed", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        new_body = mw.call_args[0][2]
+        # Active milestone (v2.0.0 → #20) first, then v0.4.0 (#10), then none (#30).
+        self.assertLess(new_body.index("#20"), new_body.index("#10"))
+        self.assertLess(new_body.index("#10"), new_body.index("#30"))
+        # Milestone column carries the compact label; a blank divider separates groups.
+        self.assertIn("| #20 | far | v2.0.0 |", new_body)
+        self.assertIn("| #10 | near | v0.4.0 |", new_body)
+        self.assertIn("| | | | | |", new_body)
+
+    def test_dropped_member_is_removed_and_reported(self):
+        """A row in the old table but no longer in frontmatter is dropped on
+        re-derive (frontmatter is membership truth) and the removal is reported
+        in the pending summary — so a batch approver sees the deletion."""
+        existing = [_gh(1, "first"), _gh(2, "second"), _gh(3, "third")]
+        track = _track(name="t", repo="o/r", issues=[1, 2],  # #3 dropped from frontmatter
+                       body=_canon_body(existing))
+        rc, mw, out = _drive(track, [_gh(1, "first"), _gh(2, "second")],
+                             ["t", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        new_body = mw.call_args[0][2]
+        self.assertNotIn("#3", new_body)
+        self.assertIn("1 row(s) removed", out)
+
+    def test_narrative_block_below_table_is_preserved(self):
+        ghs = [_gh(1, "first")]
+        track = _track(name="t", repo="o/r", issues=[1, 2],
+                       body=_canon_body(ghs, trailing="## Notes\n\nkeep me\n"))
+        rc, mw, out = _drive(track, [_gh(1, "first"), _gh(2, "second")], ["t", "--yes"])
+        self.assertEqual(rc, 0)
+        self.assertIn("## Notes\n\nkeep me", mw.call_args[0][2])
+
+
+class NarrativeTableTest(unittest.TestCase):
+    """Tracks with NO canonical marker keep the conservative in-place behavior."""
 
+    def _narrative_body(self, rows):
+        return (
+            "## Issues\n\n"
+            "| # | Title | Assignee | Status |\n"
+            "|---|---|---|---|\n"
+            + "\n".join(rows) + "\n"
+        )
+
+    def test_in_place_status_update_keeps_4col_shape(self):
+        body = self._narrative_body(["| #1 | first | — | 🔲 Open |"])
+        track = _track(name="n", repo="o/r", issues=[1], body=body)
+        rc, mw, out = _drive(track, [_gh(1, "first", "CLOSED")], ["n", "--yes"])
         self.assertEqual(rc, 0)
-        mw.assert_not_called()
-        self.assertIn("All tracks in sync.", out)
+        mw.assert_called_once()
+        new_body = mw.call_args[0][2]
+        # Narrative tables are NOT migrated to 5 columns or reordered.
+        self.assertIn("| #1 | first | — | ✅ Shipped |", new_body)
+        self.assertNotIn("Milestone", new_body)
+
+    def test_missing_row_appended_in_frontmatter_order(self):
+        body = self._narrative_body(["| #1 | first | — | 🔲 Open |"])
+        track = _track(name="n", repo="o/r", issues=[1, 5], body=body)
+        rc, mw, out = _drive(track, [_gh(1, "first"), _gh(5, "fifth", "OPEN", ["x"])],
+                             ["n", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertIn("| #5 | fifth | @x | 🔲 Open |", mw.call_args[0][2])
 
 
 if __name__ == "__main__":