@stylusnexus/work-plan 2026.6.11 → 2026.6.13

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

@@ -0,0 +1,138 @@
+"""Cross-repo duplicate-slug isolation in reconcile (#255).
+
+Identical track slugs in DIFFERENT repos are explicitly supported. Reconcile's
+in-flight state must be keyed by a per-track identity (repo, path), not by slug
+— otherwise a later same-slug track's fetch overwrites the earlier one's, and
+under `--all --yes` issues from one repo get written into the same-named track
+in ANOTHER repo (membership corruption).
+
+All gh calls are mocked; tests run offline. The fake `gh` here is REPO-AWARE
+(unlike the shared move harness) so two same-slug tracks in different repos can
+return different labeled issues.
+"""
+import json
+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
+
+
+def _track(*, slug, repo, issues=None):
+    # Path embeds the repo so two same-slug tracks have distinct file paths,
+    # mirroring how discover_tracks lays out per-repo note dirs.
+    safe_repo = repo.replace("/", "_")
+    return SimpleNamespace(
+        name=slug,
+        path=Path(f"/tmp/fake/{safe_repo}/{slug}.md"),
+        body="# fake",
+        meta={"track": slug, "status": "active",
+              "github": {"repo": repo, "issues": list(issues or [])}},
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class _RepoAwareHarness:
+    """Drives reconcile --all where labeled issues depend on BOTH repo and label.
+
+    `labeled` maps (repo, label) -> list of issue dicts that
+    `gh issue/pr list --repo <repo> --label <label>` should return.
+    """
+
+    def __init__(self, tracks, labeled):
+        self.tracks = tracks
+        self.labeled = labeled
+        self.writes = []  # (path_str, issues) per write_file call
+
+    def _fake_run(self, argv, *a, **kw):
+        out = []
+        if "--label" in argv and argv[1] == "issue":  # count issues once, not PRs
+            repo = argv[argv.index("--repo") + 1]
+            lab = argv[argv.index("--label") + 1]
+            out = self.labeled.get((repo, lab), [])
+        return MagicMock(returncode=0, stdout=json.dumps(out), stderr="")
+
+    def _fake_write(self, path, meta, body):
+        self.writes.append((str(path), list(meta.get("github", {}).get("issues") or [])))
+
+    def run(self, extra_args=None):
+        cfg = {"notes_root": "/tmp/n"}
+        with patch("commands.reconcile.subprocess.run", side_effect=self._fake_run), \
+             patch("commands.reconcile.load_config", return_value=cfg), \
+             patch("commands.reconcile.discover_tracks", return_value=self.tracks), \
+             patch("commands.reconcile.needs_confirm", return_value=False), \
+             patch("commands.reconcile.write_file", side_effect=self._fake_write), \
+             patch("commands.reconcile.prompt_input", return_value="y"):
+            rc = reconcile.run(["--all"] + (extra_args or []))
+        return rc
+
+
+class DupSlugCrossRepoTest(unittest.TestCase):
+    def test_adds_land_in_the_correct_repo_track(self):
+        """Two tracks share slug 'core' across repos o/a and o/b. Each repo
+        labels a DIFFERENT issue. Under --all --yes, each issue must land in
+        its OWN repo's track — never bleed into the same-named sibling."""
+        a = _track(slug="core", repo="o/a", issues=[])
+        b = _track(slug="core", repo="o/b", issues=[])
+        labeled = {
+            ("o/a", "track/core"): [{"number": 11, "title": "a-issue", "state": "OPEN"}],
+            ("o/b", "track/core"): [{"number": 22, "title": "b-issue", "state": "OPEN"}],
+        }
+        h = _RepoAwareHarness([a, b], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # Key off each track's real Path string (backslashes on Windows), not a
+        # hardcoded POSIX literal — the collision is the slug, not the path.
+        self.assertEqual(writes[str(a.path)], [11])
+        self.assertEqual(writes[str(b.path)], [22])
+
+    def test_failed_fetch_does_not_corrupt_same_slug_sibling(self):
+        """If repo o/a's fetch is intact but o/b's is independent, the second
+        track's results must not overwrite the first's. Here o/a adds #11 and
+        o/b adds #22; pre-fix, the shared 'core' key meant the second fetch
+        clobbered the first and #11 was lost / mis-routed."""
+        a = _track(slug="core", repo="o/a", issues=[11])  # already has #11
+        b = _track(slug="core", repo="o/b", issues=[])
+        labeled = {
+            # o/a still labels #11 (no change → no write expected for a)
+            ("o/a", "track/core"): [{"number": 11, "title": "a", "state": "OPEN"}],
+            # o/b newly labels #99
+            ("o/b", "track/core"): [{"number": 99, "title": "b", "state": "OPEN"}],
+        }
+        h = _RepoAwareHarness([a, b], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # o/a unchanged → not written. o/b gains #99 only — NOT #11.
+        self.assertNotIn(str(a.path), writes)
+        self.assertEqual(writes[str(b.path)], [99])
+
+    def test_no_cross_repo_move_between_same_slug_tracks(self):
+        """A move only fires within ONE repo. #50 sits in o/a's 'core'
+        frontmatter and is labeled for o/b's 'core' — different repos, so it
+        must stay a FLAG on o/a, not move across the repo boundary."""
+        a = _track(slug="core", repo="o/a", issues=[50])
+        b = _track(slug="core", repo="o/b", issues=[])
+        labeled = {
+            ("o/a", "track/core"): [],  # #50 lost its label in o/a
+            ("o/b", "track/core"): [{"number": 50, "title": "x", "state": "OPEN"}],
+        }
+        h = _RepoAwareHarness([a, b], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # o/a keeps #50 (no same-repo move target) → not rewritten.
+        self.assertNotIn(str(a.path), writes)
+        # o/b ADDs #50 because it now carries o/b's label — legitimate, in-repo.
+        self.assertEqual(writes.get(str(b.path)), [50])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -160,6 +160,81 @@ class CanonicalRederiveTest(unittest.TestCase):
         self.assertIn("## Notes\n\nkeep me", mw.call_args[0][2])
 
 
+class PartialFetchTest(unittest.TestCase):
+    """A degraded GitHub fetch must never overwrite valid rows with
+    '(not fetched)'. The track is skipped, left untouched, and the run exits
+    nonzero so --yes / hygiene callers see the degradation (#256)."""
+
+    def test_partial_fetch_skips_track_and_preserves_rows(self):
+        """One of several frontmatter issues missing → no write, rc=1, the
+        existing table is left exactly as it was."""
+        existing = [_gh(1, "first"), _gh(2, "second")]
+        track = _track(name="t", repo="o/r", issues=[1, 2, 3],
+                       body=_canon_body(existing + [_gh(3, "third")]))
+        original_body = track.body
+        # #3 fails to come back from the fetch.
+        rc, mw, out = _drive(track, existing, ["t", "--yes"])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertEqual(track.body, original_body)
+        self.assertNotIn("(not fetched)", out)
+        self.assertIn("#3", out)
+        self.assertNotIn("All tracks in sync.", out)
+
+    def test_total_fetch_failure_skips_track(self):
+        """Fetch returns nothing (GitHub unreachable) → track skipped, rc=1,
+        no write, table untouched."""
+        existing = [_gh(1, "first"), _gh(2, "second")]
+        track = _track(name="t", repo="o/r", issues=[1, 2],
+                       body=_canon_body(existing))
+        rc, mw, out = _drive(track, [], ["t", "--yes"])
+        self.assertEqual(rc, 1)
+        mw.assert_not_called()
+        self.assertIn("no issues", out)
+
+    def test_healthy_track_still_refreshes_alongside_degraded(self):
+        """In an --all batch, a complete-fetch track writes normally while a
+        degraded track is skipped; the run still exits nonzero overall."""
+        good_existing = [_gh(1, "first", "OPEN")]
+        good = _track(name="good", repo="o/r", issues=[1],
+                      body=_canon_body(good_existing))
+        bad = _track(name="bad", repo="o/r", issues=[5, 6],
+                     body=_canon_body([_gh(5, "fifth"), _gh(6, "sixth")]))
+
+        # good: #1 fetched (and flipped to CLOSED so there's a write); bad: #6 missing.
+        fetched = [_gh(1, "first", "CLOSED"), _gh(5, "fifth")]
+        cfg = {"notes_root": "/tmp/fake"}
+        with patch("commands.refresh_md.load_config", return_value=cfg), \
+             patch("commands.refresh_md.discover_tracks", return_value=[good, bad]), \
+             patch("commands.refresh_md.fetch_issues", return_value=fetched), \
+             patch("commands.refresh_md.write_file") as mw:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = refresh_md.run(["--all", "--yes"])
+        out = buf.getvalue()
+        self.assertEqual(rc, 1)
+        # Only the healthy track is written.
+        self.assertEqual(mw.call_count, 1)
+        written_path = mw.call_args[0][0]
+        self.assertEqual(written_path.name, "good.md")
+        self.assertIn("#6", out)  # degraded track's missing issue is reported
+
+    def test_table_only_number_absent_from_frontmatter_does_not_gate(self):
+        """A number that appears in the body table but NOT in frontmatter
+        doesn't feed the rebuild, so a fetch miss on it is harmless — the track
+        still refreshes (rc=0)."""
+        # Frontmatter membership is [1, 2]; the body also references #99, which
+        # is not in frontmatter. #99 is not fetched, but must not block.
+        existing = [_gh(1, "first", "OPEN"), _gh(2, "second")]
+        body = _canon_body(existing) + "\nSee also #99 for context.\n"
+        track = _track(name="t", repo="o/r", issues=[1, 2], body=body)
+        rc, mw, out = _drive(track, [_gh(1, "first", "CLOSED"), _gh(2, "second")],
+                             ["t", "--yes"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        self.assertNotIn("(not fetched)", mw.call_args[0][2])
+
+
 class NarrativeTableTest(unittest.TestCase):
     """Tracks with NO canonical marker keep the conservative in-place behavior."""
 

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

@@ -0,0 +1,77 @@
+"""Tests for the non-interactive remove-repo command (#290).
+
+Covers:
+- Removing an existing key → yq called with del(.repos.<key>); rc 0.
+- Missing key (not in config) → rc 1, yq NOT called.
+- Invalid key format → rc 2, yq NOT called.
+- No positional key → rc 2.
+"""
+import io
+import sys
+import unittest
+from contextlib import redirect_stdout
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from commands import remove_repo
+
+
+def _make_cfg(*, notes_root="/tmp/fake-notes", repos=None):
+    return {"notes_root": notes_root, "repos": repos or {}}
+
+
+def _drive(args, *, existing_repos=None):
+    cfg = _make_cfg(repos=existing_repos or {})
+    mock_proc = MagicMock(returncode=0, stdout="", stderr="")
+    with patch("commands.remove_repo.load_config", return_value=cfg), \
+         patch("commands.remove_repo.subprocess.run", return_value=mock_proc) as msub, \
+         patch("pathlib.Path.exists", return_value=False):
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            rc = remove_repo.run(args)
+    return rc, msub, buf.getvalue()
+
+
+class RemoveRepoTest(unittest.TestCase):
+
+    def test_removes_existing_key(self):
+        """Existing key → yq del(.repos.<key>) called; rc 0; '✓ Removed' printed."""
+        existing = {"mykey": {"github": "org/myrepo", "local": "/some/path"}}
+        rc, msub, out = _drive(["mykey"], existing_repos=existing)
+        self.assertEqual(rc, 0)
+        msub.assert_called_once()
+        yq_args = msub.call_args[0][0]
+        self.assertEqual(yq_args[0], "yq")
+        self.assertEqual(yq_args[1], "-i")
+        self.assertEqual(yq_args[2], "del(.repos.mykey)")
+        self.assertIn("✓ Removed", out)
+        # Config-only note surfaces the untouched local clone.
+        self.assertIn("config-only", out)
+
+    def test_missing_key_returns_rc1(self):
+        """Key not in config.repos → rc 1, yq NOT called."""
+        existing = {"otherkey": {"github": "org/other"}}
+        rc, msub, out = _drive(["mykey"], existing_repos=existing)
+        self.assertEqual(rc, 1)
+        msub.assert_not_called()
+        self.assertIn("not found", out)
+
+    def test_invalid_key_format_returns_rc2(self):
+        """Uppercase key → rc 2, yq NOT called (validated before load)."""
+        rc, msub, out = _drive(["MyKey"], existing_repos={"MyKey": {}})
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+        self.assertIn("not a valid key", out)
+
+    def test_no_key_returns_rc2(self):
+        """No positional key → rc 2, yq NOT called."""
+        rc, msub, out = _drive([], existing_repos={})
+        self.assertEqual(rc, 2)
+        msub.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/work-plan/work_plan.py

@@ -38,6 +38,7 @@ SUBCOMMANDS = {
     "list": "commands.list_cmd",
     "init": "commands.init",
     "init-repo": "commands.init_repo",
+    "remove-repo": "commands.remove_repo",
     "suggest-priorities": "commands.suggest_priorities",
     "group": "commands.group",
     "auto-triage": "commands.auto_triage",
@@ -51,11 +52,13 @@ SUBCOMMANDS = {
     "plan-status": "commands.plan_status",
     "--plan-status": "commands.plan_status",  # flag-style alias
     "export": "commands.export",
+    "list-open-issues": "commands.list_open_issues",
     "set": "commands.set_field",
     "new-track": "commands.new_track",
     "rename-track": "commands.rename_track",
     "set-notes-root": "commands.set_notes_root",
     "notes-vcs": "commands.notes_vcs",
+    "plan-branch": "commands.plan_branch",
 }
 
 DESCRIPTIONS = [
@@ -100,10 +103,14 @@ DESCRIPTIONS = [
      "Add frontmatter to an existing track .md file.",
      "After moving/creating a new .md file in Project Notes/<repo>/ that has no frontmatter.",
      "/work-plan init '<notes_root>/<repo-key>/foo.md'"),
-    ("init-repo", "<key> --github=<org/repo> [--local=<path>]",
-     "Bootstrap a new repo: create <notes_root>/<key>/archive/{shipped,abandoned}/ and add the repo block to your config.",
-     "When you start tracking a new GitHub repo. Replaces the old 'copy the example folder' setup.",
+    ("init-repo", "<key> --github=<org/repo> [--local=<path>] [--update [--clear-local]]",
+     "Bootstrap a new repo: create <notes_root>/<key>/archive/{shipped,abandoned}/ and add the repo block to your config. With --update on an existing key, change its local/github; --update --clear-local drops the saved local path (keeps github + other fields). --clear-local and --local are mutually exclusive.",
+     "When you start tracking a new GitHub repo. Replaces the old 'copy the example folder' setup. Use --update --clear-local to forget a stale checkout path without removing the repo.",
      "/work-plan init-repo myproject --github=your-org/myproject"),
+    ("remove-repo", "<key>",
+     "Unregister a repo: delete its block from your config (config-only). The notes folder, any tracks, and the local clone are LEFT UNTOUCHED — if a notes folder or tracks reference it they're now orphaned and can be cleaned up by hand.",
+     "When you stop tracking a repo and want it out of the sidebar/brief without deleting your notes. Completes the add/update/remove trio with init-repo.",
+     "/work-plan remove-repo myproject"),
     ("suggest-priorities", "[--repo=<folder>] [--apply]",
      "AI-assisted batch backfill of priority/PN labels.",
      "ONE-TIME setup, or whenever a wave of new unlabeled issues piles up.",
@@ -140,6 +147,10 @@ DESCRIPTIONS = [
      "Emit the viewer-ready JSON read surface (schema 1): every frontmatter'd track with repo, tier, status, visibility, blockers, next_up, an open/closed rollup, and per-issue state/assignee/milestone. Read-only; derives live from gh. Consumed by the VS Code extension.",
      "When a tool (the VS Code viewer, or any script) needs structured track state instead of the human-facing brief/orient text.",
      "/work-plan export --json"),
+    ("list-open-issues", "--repo=<owner/name> [--exclude=<csv-issue-numbers>]",
+     "Emit a repo's OPEN issues as JSON ({repo, issues:[{number,title,state,assignee,milestone}]}) — the same issue shape as export. Read-only; derives live from gh. --repo takes a bare org/repo slug; --exclude drops the given issue numbers (the viewer passes a track's current issues so already-slotted ones don't reappear). Unlike export's `untracked`, this includes issues tracked by OTHER tracks, since those are valid slot targets.",
+     "When the VS Code viewer's Slot command needs the repo's open issues as a pick-list (the per-track export can't supply issues not yet in the track).",
+     "/work-plan list-open-issues --repo=stylusnexus/work-plan-toolkit --exclude=87,91"),
     ("set", "<track | track@repo> field=value [field=value …] [--repo=<key>] [--confirm=<token>]",
      "Guarded edit of a track's frontmatter fields (status, launch_priority, milestone_alignment, blockers, next_up). Validates field names + status values; blockers/next_up take comma-separated issue numbers. Setting `next_up` here writes ONLY the frontmatter field — for next_up plus a session-log entry (and a body refresh), use `handoff --set-next` instead. Writes into a PUBLIC repo only with a confirm token: without one it prints {needs_confirm, reason, token} and makes no change (the VS Code viewer surfaces that as a modal, then re-invokes with --confirm=<token>).",
      "Programmatic/GUI edits that have no dedicated verb — e.g. the VS Code extension changing a status or blockers list. On the terminal you'll usually use the named verbs instead.",
@@ -164,6 +175,10 @@ DESCRIPTIONS = [
      "Opt-in LOCAL version control for the private notes_root tier — history/undo for tracks you keep on your machine, never pushed. `init` git-inits notes_root as a personal repo (initial commit of existing tracks) and turns on auto-commit; with --no-enable it inits without enabling. For safety it REFUSES a notes_root that already has a git remote or is a repo work-plan didn't create, and only ever commits the files a command changed — private notes stay un-pushable and your unrelated edits are never swept in. `enable`/`disable` toggle auto-commit (history is kept either way). `status` reports whether notes_root is a repo, whether auto-commit is on, and the last commit (add --json for the machine-readable shape the VS Code viewer polls). `undo [<sha>]` reverts a commit (default HEAD) — the last edit, by default. When auto-commit is on, every track-mutating command (slot/group/handoff/close/set/…) writes an undoable commit; the shared tier is unaffected (it's versioned by its own repo).",
      "ONE-TIME setup when you want a git safety net for private tracks — so a bulk slot or a bad edit is reversible by default instead of needing a manual /tmp backup. `undo` reverses the last edit.",
      "/work-plan notes-vcs init"),
+    ("plan-branch", "<init|status|push> <repo> [--branch=<name>] [--confirm=<token>] [--dry-run] [--json]",
+     "Set up and share a repo's canonical SHARED-tier plan branch (#260). The shared `.work-plan/` tier is pinned to ONE per-repo `plan_branch`, read/written through a dedicated git worktree, so planning never diverges across code branches or pollutes PR / deploy diffs. `init <repo>` creates that branch + a `.work-plan/` skeleton (default an ORPHAN `work-plan/plan`, zero shared history with code like gh-pages; override with --branch) and records `plan_branch` in config — or CONNECTS to a teammate's already-published branch if one exists. init is LOCAL ONLY (no push). `status <repo>` reports whether the branch exists, is published to origin, and how many commits are unpushed (--json for the machine shape). `push <repo>` shares it: on a PUBLIC repo it prints a confirm heads-up + token and exits (re-run with --confirm=<token>); --dry-run previews the commits that would push. Requires a repo registered via init-repo with a local clone path.",
+     "ONE-TIME per repo when you want the shared plan to live on its own branch (off dev/main) so planning churn never lands in feature PRs or the deploy diff — yet the CLI + VS Code viewer always show the canonical plan from any checkout. `push` is the deliberate step that shares it with teammates.",
+     "/work-plan plan-branch init work-plan-toolkit"),
 ]
 
 
@@ -236,9 +251,16 @@ def main(argv: list[str]) -> int:
     # Snapshot notes_root's dirty set BEFORE the command so we can commit only
     # what this command changes (and never fold in pre-existing edits, #244-vcs).
     pre = _notes_precommit_state(sub)
+    # Same discipline for each plan_branch repo's shared tier (#260): snapshot
+    # the dirty .work-plan/ paths per worktree BEFORE the run, commit only the
+    # delta AFTER — so an unrelated subcommand never sweeps in pre-existing edits.
+    shared_pre = _shared_precommit_state(sub)
     rc = module.run(argv[2:])
-    if rc == 0 and pre is not None:
-        _commit_changed_notes(pre, argv[1:])
+    if rc == 0:
+        if pre is not None:
+            _commit_changed_notes(pre, argv[1:])
+        if shared_pre:
+            _commit_shared_writes(shared_pre, argv[1:])
     return rc
 
 
@@ -246,7 +268,10 @@ def main(argv: list[str]) -> int:
 # (Flag aliases like --brief/--plan-status normalise by stripping leading dashes.)
 _READONLY_SUBCOMMANDS = frozenset({
     "brief", "orient", "where-was-i", "list", "coverage", "duplicates",
-    "plan-status", "export", "notes-vcs",
+    "plan-status", "export", "list-open-issues", "notes-vcs",
+    # plan-branch manages its OWN commits on the plan branch (init seeds +
+    # commits the skeleton itself); the auto-commit hooks must not also fire.
+    "plan-branch",
 })
 
 
@@ -306,5 +331,69 @@ def _commit_changed_notes(pre, parts: list[str]) -> None:
         return
 
 
+def _shared_precommit_state(sub: str):
+    """Snapshot each `plan_branch` repo's dirty `.work-plan/` paths BEFORE a
+    command, so we can later commit only what the command changed. Returns a
+    list of (key, branch, worktree, before_paths) — one per plan_branch repo
+    whose worktree could be ensured — or None. Best-effort; never raises.
+
+    Read-only verbs and legacy (no-plan_branch) repos are skipped — the latter's
+    shared tier is the working tree and is never auto-committed.
+    """
+    if sub.lstrip("-") in _READONLY_SUBCOMMANDS:
+        return None
+    try:
+        from lib.config import load_config
+        from lib import plan_worktree
+        from pathlib import Path
+
+        cfg = load_config()
+        states = []
+        for key, entry in (cfg.get("repos") or {}).items():
+            if not entry or not entry.get("plan_branch") or not entry.get("local"):
+                continue
+            branch = entry["plan_branch"]
+            worktree = plan_worktree.ensure_worktree(
+                Path(entry["local"]).expanduser(), branch
+            )
+            if worktree is None:
+                continue
+            before = plan_worktree.dirty_work_plan_paths(worktree)
+            states.append((key, branch, worktree, set(before)))
+        return states or None
+    except Exception:
+        return None
+
+
+def _commit_shared_writes(pre_states, parts: list[str]) -> None:
+    """Commit ONLY the `.work-plan/` paths each command newly changed (after −
+    before) per plan_branch repo, on that repo's plan_branch via its worktree
+    (#260). Leaves pre-existing dirty plan files untouched. Best-effort; never
+    raises and never changes the command's exit code. Local commit only (pushing
+    is a deliberate follow-up step).
+    """
+    try:
+        from lib import plan_worktree
+    except Exception:
+        return
+    message = "work-plan " + " ".join(parts)
+    for key, branch, worktree, before in (pre_states or []):
+        # Per-repo isolation: one repo's git failure must not skip the others.
+        try:
+            changed = sorted(set(plan_worktree.dirty_work_plan_paths(worktree)) - before)
+            if not changed:
+                continue
+            sha = plan_worktree.commit_shared_tier(worktree, message, changed)
+            if sha:
+                print(f"⏺ shared plan committed {sha} on {branch} ({key}) — "
+                      f"not yet pushed", file=sys.stderr)
+            else:
+                print(f"⚠ shared plan changes in {key} ({branch}) were NOT "
+                      f"committed (git refused) — review the worktree.",
+                      file=sys.stderr)
+        except Exception:
+            continue
+
+
 if __name__ == "__main__":
     sys.exit(main(sys.argv))