@stylusnexus/work-plan 2026.6.9 → 2026.6.10

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

@@ -18,6 +18,7 @@ Covers:
 """
 import io
 import json
+import subprocess
 import sys
 import unittest
 from contextlib import redirect_stdout
@@ -307,7 +308,7 @@ class NewTrackCommandTest(unittest.TestCase):
         self.assertEqual(rc, 0)
         meta = mw.call_args[0][1]
         for key in ("track", "status", "launch_priority", "milestone_alignment",
-                    "github", "related_tracks", "last_touched", "last_handoff",
+                    "github", "depends_on", "last_touched", "last_handoff",
                     "next_up", "blockers"):
             self.assertIn(key, meta, f"meta missing key: {key}")
 
@@ -319,12 +320,12 @@ class NewTrackCommandTest(unittest.TestCase):
         self.assertEqual(meta["github"]["issues"], [])
         self.assertEqual(meta["github"]["branches"], [])
 
-    def test_meta_related_tracks_next_up_blockers_empty(self):
-        """New track starts with empty related_tracks, next_up, blockers."""
+    def test_meta_depends_on_next_up_blockers_empty(self):
+        """New track starts with empty depends_on, next_up, blockers."""
         rc, mw, out = _drive(["myrepo", "my-feature"], vis="PRIVATE")
         self.assertEqual(rc, 0)
         meta = mw.call_args[0][1]
-        self.assertEqual(meta["related_tracks"], [])
+        self.assertEqual(meta["depends_on"], [])
         self.assertEqual(meta["next_up"], [])
         self.assertEqual(meta["blockers"], [])
 
@@ -441,5 +442,169 @@ class NewTrackCommandTest(unittest.TestCase):
         mw.assert_called_once()
 
 
+# ---------------------------------------------------------------------------
+# Phase D: --commit flag tests
+# ---------------------------------------------------------------------------
+
+CLONE_ROOT = "/tmp/fake-clone"
+
+
+def _make_cfg_with_local(*, local=CLONE_ROOT):
+    """Config with a repo entry that has a local clone path."""
+    return {
+        "notes_root": NOTES_ROOT,
+        "repos": {
+            "myrepo": {"github": "org/myrepo", "local": local},
+        },
+    }
+
+
+class NewTrackCommitFlagTest(unittest.TestCase):
+    """Tests for --commit flag on new-track (Phase D)."""
+
+    def _drive_shared(self, args, *, git_returncode=0, path_exists=False):
+        """Drive new-track with a shared-tier setup (local clone is a valid git repo)."""
+        cfg = _make_cfg_with_local()
+
+        def _path_exists(self):
+            # NOTES_ROOT itself exists
+            if self == Path(NOTES_ROOT):
+                return True
+            # .git dir inside the clone root exists (valid git repo)
+            if str(self) == f"{CLONE_ROOT}/.git":
+                return True
+            # The clone root itself exists
+            if str(self) == CLONE_ROOT:
+                return True
+            # The target .md path: controlled by path_exists
+            if self.suffix == ".md":
+                return path_exists
+            return True
+
+        def _is_dir(self):
+            s = str(self)
+            if s.endswith(".md"):
+                return False
+            return True
+
+        # git subprocess: first call (rev-parse), then add, then commit
+        git_results = [
+            MagicMock(returncode=0, stdout="main\n", stderr=""),       # rev-parse
+            MagicMock(returncode=git_returncode, stdout="", stderr="error msg"),  # add
+            MagicMock(returncode=git_returncode, stdout="", stderr=""),           # commit
+        ]
+        git_call_index = {"n": 0}
+
+        def _git_run(cmd, **kwargs):
+            idx = git_call_index["n"]
+            git_call_index["n"] += 1
+            if git_returncode != 0 and idx > 0:
+                raise subprocess.CalledProcessError(git_returncode, cmd, stderr="error msg")
+            return git_results[min(idx, len(git_results) - 1)]
+
+        with patch("commands.new_track.load_config", return_value=cfg), \
+             patch("commands.new_track.write_file") as mw, \
+             patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+             patch("pathlib.Path.exists", _path_exists), \
+             patch("pathlib.Path.is_dir", _is_dir), \
+             patch("pathlib.Path.mkdir"), \
+             patch("commands.new_track.subprocess.run", side_effect=_git_run) as msub:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = new_track.run(args)
+        return rc, mw, msub, buf.getvalue()
+
+    def test_commit_shared_track_calls_git_add_then_commit(self):
+        """--commit on a shared track: git -C <clone_root> add <file> called,
+        then git -C <clone_root> commit called; path-scoped (not git add .)."""
+        rc, mw, msub, out = self._drive_shared(
+            ["myrepo", "my-feature", "--commit"]
+        )
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        # Should have made git calls: rev-parse, add, commit
+        calls = msub.call_args_list
+        # Find the add and commit calls (skip rev-parse at index 0)
+        git_cmds = [c[0][0] for c in calls]
+        add_calls = [c for c in git_cmds if "add" in c]
+        commit_calls = [c for c in git_cmds if "commit" in c]
+        self.assertEqual(len(add_calls), 1, "exactly one git add call expected")
+        self.assertEqual(len(commit_calls), 1, "exactly one git commit call expected")
+        # Verify add is path-scoped (not "git add .")
+        add_argv = add_calls[0]
+        self.assertNotIn(".", add_argv, "git add must be path-scoped, not 'git add .'")
+        self.assertIn("-C", add_argv)
+        # The file argument should end in .md
+        file_arg = add_argv[-1]
+        self.assertTrue(file_arg.endswith(".md"), f"expected .md path, got: {file_arg}")
+        # Commit message should mention the slug
+        commit_argv = commit_calls[0]
+        msg_idx = commit_argv.index("-m") + 1
+        self.assertIn("my-feature", commit_argv[msg_idx])
+
+    def test_commit_shared_track_path_scoped_not_git_add_dot(self):
+        """The git add call must never use '.' as the file argument."""
+        rc, mw, msub, out = self._drive_shared(
+            ["myrepo", "path-scoped-test", "--commit"]
+        )
+        self.assertEqual(rc, 0)
+        git_cmds = [c[0][0] for c in msub.call_args_list]
+        add_calls = [c for c in git_cmds if "add" in c]
+        self.assertEqual(len(add_calls), 1)
+        self.assertNotIn(".", add_calls[0])
+
+    def test_commit_private_track_warns_and_skips_git(self):
+        """--commit on a private track (notes_root, not .work-plan) → warning
+        printed, git NOT called."""
+        cfg = _make_cfg()  # no local clone → private route
+
+        def _path_exists(self):
+            if self == Path(NOTES_ROOT):
+                return True
+            if self.suffix == ".md":
+                return False
+            return True
+
+        with patch("commands.new_track.load_config", return_value=cfg), \
+             patch("commands.new_track.write_file") as mw, \
+             patch("lib.write_guard.repo_visibility", return_value="PRIVATE"), \
+             patch("pathlib.Path.exists", _path_exists), \
+             patch("pathlib.Path.mkdir"), \
+             patch("commands.new_track.subprocess.run") as msub:
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                rc = new_track.run(["myrepo", "private-track", "--commit"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        msub.assert_not_called()
+        self.assertIn("--commit ignored", buf.getvalue())
+
+    def test_commit_git_failure_is_non_fatal(self):
+        """--commit with git add failing → rc still 0, warning printed."""
+        rc, mw, msub, out = self._drive_shared(
+            ["myrepo", "my-feature", "--commit"],
+            git_returncode=1,
+        )
+        self.assertEqual(rc, 0, "git failure must be non-fatal")
+        mw.assert_called_once()
+        self.assertIn("⚠", out)
+
+    def test_no_commit_flag_no_git_calls(self):
+        """Without --commit: git is never called, even for a shared track."""
+        rc, mw, msub, out = self._drive_shared(["myrepo", "my-feature"])
+        self.assertEqual(rc, 0)
+        mw.assert_called_once()
+        msub.assert_not_called()
+
+    def test_commit_success_prints_committed_line(self):
+        """Successful --commit → output contains 'committed' and the slug."""
+        rc, mw, msub, out = self._drive_shared(
+            ["myrepo", "my-feature", "--commit"]
+        )
+        self.assertEqual(rc, 0)
+        self.assertIn("committed", out)
+        self.assertIn("my-feature", out)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,78 @@
+"""Tests for lib/notes_readme.py — seed_readme."""
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+SKILL_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(SKILL_ROOT))
+
+from lib.notes_readme import seed_readme, README_CONTENT
+
+
+class SeedReadmeTest(unittest.TestCase):
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.work_plan_dir = Path(self._tmp.name) / ".work-plan"
+        self.work_plan_dir.mkdir()
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_writes_readme_when_absent_returns_true(self):
+        """seed_readme writes README.md when it doesn't exist; returns True."""
+        result = seed_readme(self.work_plan_dir)
+        self.assertTrue(result)
+        readme = self.work_plan_dir / "README.md"
+        self.assertTrue(readme.exists())
+
+    def test_idempotent_existing_readme_returns_false(self):
+        """seed_readme skips when README.md already exists; returns False."""
+        readme = self.work_plan_dir / "README.md"
+        readme.write_text("existing content", encoding="utf-8")
+        result = seed_readme(self.work_plan_dir)
+        self.assertFalse(result)
+        # Content not overwritten
+        self.assertEqual(readme.read_text(encoding="utf-8"), "existing content")
+
+    def test_idempotent_second_call_returns_false(self):
+        """Calling seed_readme twice: first call True, second call False."""
+        first = seed_readme(self.work_plan_dir)
+        second = seed_readme(self.work_plan_dir)
+        self.assertTrue(first)
+        self.assertFalse(second)
+
+    def test_readme_content_contains_shared_tier(self):
+        """Written README contains 'shared tier'."""
+        seed_readme(self.work_plan_dir)
+        content = (self.work_plan_dir / "README.md").read_text(encoding="utf-8")
+        self.assertIn("shared tier", content)
+
+    def test_readme_content_contains_private_flag(self):
+        """Written README mentions '--private'."""
+        seed_readme(self.work_plan_dir)
+        content = (self.work_plan_dir / "README.md").read_text(encoding="utf-8")
+        self.assertIn("--private", content)
+
+    def test_readme_content_contains_work_plan_toolkit(self):
+        """Written README references 'work-plan-toolkit'."""
+        seed_readme(self.work_plan_dir)
+        content = (self.work_plan_dir / "README.md").read_text(encoding="utf-8")
+        self.assertIn("work-plan-toolkit", content)
+
+    def test_absent_readme_in_existing_folder_is_written(self):
+        """Caller's responsibility: seed_readme writes when README absent,
+        regardless of whether the dir is 'new' or 'existing'.
+        (The deletion-as-opt-out contract is enforced by callers who only
+        call seed_readme when creating a new directory, not by the function.)
+        """
+        # Simulate an existing dir that lost its README (from the function's POV,
+        # the file is just absent → it writes)
+        result = seed_readme(self.work_plan_dir)
+        self.assertTrue(result)
+        self.assertTrue((self.work_plan_dir / "README.md").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,121 @@
+"""Non-interactive guard for the prompt helpers (regression test for #183).
+
+When `work_plan.py` is launched with stdin wired to a pipe/socket that stays
+open but never delivers a line (the VS Code extension does exactly this),
+`input()` blocks forever — no data, no EOF. The fix makes prompt_input /
+prompt_yes_no / prompt_lines fall back to their default when stdin is not a
+TTY, and only call input() when it is.
+
+These tests fake stdin's isatty() rather than touching the real terminal, and
+assert input() is NOT called on the non-TTY path (so a regression that drops
+the guard would deadlock under a real pipe — here it would call the patched
+input and the assertion would fire instead of hanging).
+"""
+import io
+import sys
+import unittest
+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 lib import prompts
+
+
+class _FakeStdin:
+    def __init__(self, tty: bool):
+        self._tty = tty
+
+    def isatty(self) -> bool:
+        return self._tty
+
+
+class NonInteractiveGuardTest(unittest.TestCase):
+    """No TTY → return the default immediately, never call input()."""
+
+    def test_prompt_input_returns_default_without_reading(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("Apply? [y/N]", default="N")
+        self.assertEqual(out, "N")
+
+    def test_prompt_input_default_is_empty_string_by_default(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("anything")
+        self.assertEqual(out, "")
+
+    def test_prompt_yes_no_returns_false_without_reading(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_yes_no()
+        self.assertFalse(out)
+
+    def test_prompt_lines_returns_empty_without_reading(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=False)), \
+             mock.patch("builtins.input", side_effect=AssertionError("input() must not be called")):
+            out = prompts.prompt_lines()
+        self.assertEqual(out, [])
+
+    def test_guard_false_when_stdin_is_none(self):
+        with mock.patch.object(prompts.sys, "stdin", None):
+            self.assertFalse(prompts._stdin_is_interactive())
+
+    def test_guard_false_when_isatty_raises(self):
+        class Broken:
+            def isatty(self):
+                raise ValueError("I/O operation on closed file")
+        with mock.patch.object(prompts.sys, "stdin", Broken()):
+            self.assertFalse(prompts._stdin_is_interactive())
+
+
+class InteractivePathStillReadsTest(unittest.TestCase):
+    """With a TTY, the helpers still call input() and honour the reply."""
+
+    def test_prompt_input_reads_when_tty(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="  hello  "):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("q")
+        self.assertEqual(out, "hello")
+
+    def test_prompt_input_blank_reply_falls_back_to_default(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="   "):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("q", default="def")
+        self.assertEqual(out, "def")
+
+    def test_prompt_yes_no_true_only_on_y(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="Y"):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                self.assertTrue(prompts.prompt_yes_no())
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", return_value="n"):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                self.assertFalse(prompts.prompt_yes_no())
+
+    def test_prompt_input_eof_returns_default_when_tty(self):
+        with mock.patch.object(prompts.sys, "stdin", _FakeStdin(tty=True)), \
+             mock.patch("builtins.input", side_effect=EOFError):
+            buf = io.StringIO()
+            with redirect_stdout(buf):
+                out = prompts.prompt_input("q", default="d")
+        self.assertEqual(out, "d")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,154 @@
+"""Cross-track auto-move detection in reconcile (#163).
+
+When an issue sits in track A's frontmatter but is now labeled for exactly one
+OTHER active track B in the same repo (a relabel), reconcile proposes a MOVE:
+remove from A, add to B — instead of leaving it as a dangling FLAG on A and a
+fresh ADD on B (which would duplicate it across both tracks).
+
+All gh calls are mocked; tests run offline. needs_confirm is patched so the
+public-repo gate is exercised without a real `gh repo view`.
+"""
+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="ok/ok", issues=None):
+    return SimpleNamespace(
+        name=slug,
+        path=Path(f"/tmp/fake/{slug}.md"),
+        body="# fake",
+        meta={"track": slug, "status": "active",
+              "github": {"repo": repo, "issues": list(issues or [])}},
+        has_frontmatter=True,
+        repo=repo,
+    )
+
+
+class _Harness:
+    """Drives reconcile --all over a set of tracks with a label→issues map.
+
+    `labeled` maps a GitHub label string to the list of issue dicts that
+    `gh issue/pr list --label <label>` should return.
+    """
+
+    def __init__(self, tracks, labeled, *, private=True):
+        self.tracks = tracks
+        self.labeled = labeled
+        self.private = private
+        self.writes = []  # (path_name, issues) per write_file call
+
+    def _fake_run(self, argv, *a, **kw):
+        out = []
+        if "--label" in argv and argv[1] == "issue":  # only count issues once
+            lab = argv[argv.index("--label") + 1]
+            out = self.labeled.get(lab, [])
+        return MagicMock(returncode=0, stdout=json.dumps(out), stderr="")
+
+    def _fake_write(self, path, meta, body):
+        self.writes.append((path.name, list(meta.get("github", {}).get("issues") or [])))
+
+    def run(self, extra_args=None):
+        cfg = {"notes_root": "/tmp/n", "repos": {"ok": {"github": "ok/ok"}}}
+        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=not self.private), \
+             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 AutoMoveTest(unittest.TestCase):
+    def test_relabel_moves_issue_from_a_to_b(self):
+        # #50 is in alpha's frontmatter but now carries only track/beta.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        self.assertEqual(writes["alpha.md"], [])      # removed from source
+        self.assertEqual(writes["beta.md"], [50])     # added to destination
+        self.assertEqual(len(h.writes), 2)            # each side written once
+
+    def test_ambiguous_target_is_not_moved_out_of_source(self):
+        # #50 lost alpha's label and is labeled for BOTH beta and gamma →
+        # ambiguous target, so reconcile must NOT move it out of alpha. (beta
+        # and gamma each legitimately ADD it, since it carries both labels —
+        # that's normal membership-follows-labels behaviour, not a move.) The
+        # point of this test: alpha keeps #50, the move logic does not fire.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        gamma = _track(slug="gamma", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "x", "state": "OPEN"}],
+            "track/gamma": [{"number": 50, "title": "x", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta, gamma], labeled)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        writes = dict(h.writes)
+        # alpha must NOT be rewritten — #50 stays (no unambiguous move target).
+        self.assertNotIn("alpha.md", writes)
+        # beta and gamma each ADD #50 (it is labeled for both).
+        self.assertEqual(writes.get("beta.md"), [50])
+        self.assertEqual(writes.get("gamma.md"), [50])
+
+    def test_draft_reports_move_but_writes_nothing(self):
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled)
+        rc = h.run(extra_args=["--draft"])
+        self.assertEqual(rc, 0)
+        self.assertEqual(h.writes, [])
+
+    def test_public_destination_skipped_under_yes(self):
+        # Destination is PUBLIC → under --yes the move is skipped (no silent
+        # membership write to a shared track); source is left untouched too.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled, private=False)
+        rc = h.run(extra_args=["--yes"])
+        self.assertEqual(rc, 0)
+        self.assertEqual(h.writes, [])  # nothing written when dst is public
+
+    def test_move_does_not_duplicate_as_add_on_destination(self):
+        # The destination must NOT also try to ADD #50 (which would be the
+        # naive behaviour); it arrives exactly once, via the move.
+        alpha = _track(slug="alpha", issues=[50])
+        beta = _track(slug="beta", issues=[])
+        labeled = {
+            "track/alpha": [],
+            "track/beta": [{"number": 50, "title": "moved", "state": "OPEN"}],
+        }
+        h = _Harness([alpha, beta], labeled)
+        h.run(extra_args=["--yes"])
+        writes = dict(h.writes)
+        self.assertEqual(writes["beta.md"].count(50), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -14,6 +14,7 @@ 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
@@ -141,6 +142,25 @@ class ReadOnlyContractTest(unittest.TestCase):
         self._assert_read_only(captured)
         mock_write.assert_called_once()
 
+    def test_yes_applies_without_prompt_and_writes_local_only(self):
+        # --yes (non-interactive, e.g. from the VS Code extension) applies the
+        # proposed ADDs without ever calling prompt_input, and the only write
+        # is the local frontmatter file — never gh. This is the #183 fix: a
+        # piped/no-TTY run must not hang on the prompt.
+        track = _fake_track(slug="epsilon", 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="n", extra_args=["--yes"],
+        )
+        self.assertEqual(rc, 0)
+        self._assert_read_only(captured)
+        mock_prompt.assert_not_called()
+        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
@@ -162,5 +182,77 @@ class ReadOnlyContractTest(unittest.TestCase):
         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()