Merge pull request #123 from atomikpanda/feat/hub-worktree-layout

hub worktree layout

Author: atomikpanda

docs/superpowers/plans/2026-04-28-hub-worktree-layout.md

@@ -1,6 +1,6 @@
 [project]
 name = "mothership"
-version = "0.1.1"
+version = "0.2.0"
 description = "Phase-based workflow engine for multi-repo AI development"
 requires-python = ">=3.14"
 dependencies = [
@@ -33,4 +33,5 @@ dev = [
     "pytest>=8.0",
     "pytest-tmp-files>=0.0.2",
     "pytest-asyncio>=0.23",
+    "coverage>=7.13.5",
 ]

docs/superpowers/specs/2026-04-28-hub-worktree-layout-design.md

@@ -35,6 +35,93 @@ def audit(
             output.error(str(e))
             raise typer.Exit(code=1)
 
+        # Surface passive worktree issues (passive_drift, passive_fetch_failed,
+        # passive_dirty_worktree). Iterates state.tasks; for each (task, repo)
+        # in task.passive_repos, audits the worktree and merges issues into
+        # the matching RepoAudit entry in `report`.
+        try:
+            from mship.core.repo_state import (
+                audit_passive_worktrees, RepoAudit, AuditReport, Issue,
+            )
+            state = container.state_manager().load()
+
+            # Group passive worktrees by task. For each task, run a separate
+            # audit so messages can include the task slug for disambiguation.
+            passive_per_task: list[tuple[str, dict, dict, dict]] = []
+            for task_slug, task in state.tasks.items():
+                if not task.passive_repos:
+                    continue
+                paths: dict = {}
+                refs: dict = {}
+                canonicals: dict = {}
+                for repo_name in task.passive_repos:
+                    if repo_name not in config.repos:
+                        continue
+                    rc = config.repos[repo_name]
+                    ref = getattr(rc, "expected_branch", None) or getattr(rc, "base_branch", None)
+                    if ref is None:
+                        continue
+                    wt = task.worktrees.get(repo_name)
+                    if wt is None:
+                        continue
+                    paths[repo_name] = wt
+                    refs[repo_name] = ref
+                    canonicals[repo_name] = rc.path
+                if paths:
+                    passive_per_task.append((task_slug, paths, refs, canonicals))
+
+            extra_issues_per_repo: dict[str, list] = {}
+            for task_slug, paths, refs, canonicals in passive_per_task:
+                per_repo = audit_passive_worktrees(paths, refs, canonicals)
+                for repo_name, issues in per_repo.items():
+                    if not issues:
+                        continue
+                    # Tag each issue with the task slug for disambiguation
+                    tagged = [
+                        Issue(i.code, i.severity,
+                              f"[task {task_slug}] {i.message}")
+                        for i in issues
+                    ]
+                    extra_issues_per_repo.setdefault(repo_name, []).extend(tagged)
+
+            if extra_issues_per_repo:
+                # Rebuild report.repos so RepoAudit instances containing passive
+                # repos pick up the merged issues.
+                new_repos = []
+                seen: set[str] = set()
+                for r in report.repos:
+                    seen.add(r.name)
+                    extra = extra_issues_per_repo.get(r.name, [])
+                    if extra:
+                        new_repos.append(RepoAudit(
+                            name=r.name,
+                            path=r.path,
+                            current_branch=r.current_branch,
+                            issues=tuple(list(r.issues) + extra),
+                        ))
+                    else:
+                        new_repos.append(r)
+                # Repos with passive issues but not in the audit_repos report
+                # (e.g. excluded by --repos filter). Append fresh entries.
+                for repo_name, extra in extra_issues_per_repo.items():
+                    if repo_name in seen:
+                        continue
+                    rc = config.repos.get(repo_name)
+                    if rc is None:
+                        continue
+                    new_repos.append(RepoAudit(
+                        name=repo_name,
+                        path=rc.path,
+                        current_branch=None,
+                        issues=tuple(extra),
+                    ))
+                report = AuditReport(repos=tuple(new_repos))
+        except Exception as e:
+            # Best-effort: failing to audit passive worktrees should not break
+            # the canonical audit output.
+            if not json_output:
+                output.warning(f"passive audit unavailable: {e}")
+
         if json_output:
             import json as _json
             print(_json.dumps(report.to_json(workspace=config.workspace), indent=2))

pyproject.toml

@@ -14,7 +14,12 @@ def doctor():
 
         config = container.config()
         shell = container.shell()
-        checker = DoctorChecker(config, shell, state_dir=container.state_dir())
+        checker = DoctorChecker(
+            config,
+            shell,
+            state_dir=container.state_dir(),
+            workspace_root=container.config_path().parent,
+        )
         report = checker.run()
 
         if output.is_tty:

src/mship/cli/audit.py

@@ -78,6 +78,14 @@ def test_cmd(
         resolved = resolve_for_command("exec", state, task, output)
         t = resolved.task
 
+        if t.active_repo and t.active_repo in t.passive_repos:
+            output.error(
+                f"Cannot run tests: active_repo '{t.active_repo}' is passive. "
+                f"Switch to an affected repo first, or close & respawn with "
+                f"`--repos {t.active_repo},...` to make it editable."
+            )
+            raise typer.Exit(code=1)
+
         from pathlib import Path as _P
         from mship.cli._cwd_check import format_cwd_warning
         if t.active_repo is not None and t.active_repo in t.worktrees:

src/mship/cli/doctor.py

@@ -30,19 +30,32 @@ def check_commit(toplevel: str = typer.Argument(..., help="git rev-parse --show-
         try:
             tl = Path(toplevel).resolve()
             registered = [
-                (slug, Path(wt).resolve())
+                (slug, repo, Path(wt).resolve())
                 for slug, task in state.tasks.items()
-                for wt in task.worktrees.values()
+                for repo, wt in task.worktrees.items()
             ]
         except (OSError, RuntimeError):
             raise typer.Exit(code=0)
 
         matched_task = None
-        for slug, wt in registered:
+        matched_repo: str | None = None
+        for slug, repo, wt in registered:
             if tl == wt:
                 matched_task = state.tasks[slug]
+                matched_repo = repo
                 break
 
+        if matched_task is not None and matched_repo in matched_task.passive_repos:
+            import sys
+            sys.stderr.write(
+                f"⛔ mship: refusing commit — {tl} is a passive worktree of "
+                f"`{matched_repo}` for task `{matched_task.slug}`.\n"
+                f"   To edit {matched_repo}, close this task and respawn with "
+                f"`--repos {matched_repo},...`\n"
+                f"   (or `git commit --no-verify` to override).\n"
+            )
+            raise typer.Exit(code=1)
+
         if matched_task is not None:
             # Reconcile gate (per-task, unchanged behavior)
             try:
@@ -88,7 +101,7 @@ def _fetcher(branches, worktrees_by_branch):
             f"\u26d4 mship: refusing commit — {tl} is not a registered worktree.\n"
             f"   Active task worktrees:\n"
         )
-        for slug, wt in registered:
+        for slug, _repo, wt in registered:
             sys.stderr.write(f"     {wt} ({slug})\n")
 
         # If the rejected toplevel has uncommitted changes, it's almost
@@ -110,7 +123,7 @@ def _fetcher(branches, worktrees_by_branch):
                 f"\n   {tl} has uncommitted changes — looks like edits landed here\n"
                 f"   instead of the worktree. To move them:\n"
             )
-            for slug, wt in registered:
+            for slug, _repo, wt in registered:
                 q_wt = shlex.quote(str(wt))
                 sys.stderr.write(
                     f"     git -C {q_tl} stash push -u -m {slug}-misrouted\n"

src/mship/cli/exec.py

@@ -28,6 +28,14 @@ def phase(
         resolved = resolve_for_command("phase", state, task, output)
         t = resolved.task
 
+        if t.active_repo and t.active_repo in t.passive_repos:
+            output.error(
+                f"Cannot transition phase: active_repo '{t.active_repo}' is passive. "
+                f"Switch to an affected repo first, or close & respawn with "
+                f"`--repos {t.active_repo},...` to make it editable."
+            )
+            raise typer.Exit(code=1)
+
         if t.blocked_reason and not force:
             output.error(
                 f"Task is blocked: {t.blocked_reason}. "

src/mship/cli/internal.py

@@ -36,8 +36,9 @@ def switch(
             target = t.active_repo
             is_switch = False
         else:
-            if repo not in t.affected_repos:
-                valid = ", ".join(t.affected_repos)
+            all_repos = list(t.affected_repos) + [r for r in t.passive_repos if r not in t.affected_repos]
+            if repo not in all_repos:
+                valid = ", ".join(all_repos)
                 output.error(f"Unknown repo '{repo}'. Valid: {valid}.")
                 raise typer.Exit(code=1)
             target = repo
@@ -63,10 +64,13 @@ def _apply(s):
 
         handoff = build_handoff(config, state_mgr.load(), shell, log_mgr, repo=target, task_slug=t.slug)
 
+        is_passive = target in t.passive_repos
+
         if not output.is_tty:
             json_payload = handoff.to_json()
             json_payload["resolved_task"] = resolved.task.slug
             json_payload["resolution_source"] = resolved.source
+            json_payload["is_passive"] = is_passive
             output.json(json_payload)
             return
 
@@ -104,6 +108,15 @@ def _apply(s):
         lines.append(
             f"[bold]{verb}:[/bold] {handoff.repo} (task: {handoff.task_slug}, phase: {handoff.phase})"
         )
+        if is_passive:
+            repo_cfg = config.repos.get(target)
+            ref = (repo_cfg.expected_branch or repo_cfg.base_branch) if repo_cfg else target
+            lines.append(
+                f"[yellow]⚠[/yellow] Switched to `{target}` (passive — read-only on `{ref}`)."
+            )
+            lines.append(
+                f"  To edit, close this task and respawn with `--repos {target},...`"
+            )
         lines.append(f"[bold]Branch:[/bold]   {handoff.branch}")
         lines.append(f"[bold]Worktree:[/bold] {handoff.worktree_path}")
         lines.append("")

src/mship/cli/phase.py

@@ -9,6 +9,10 @@ def register(app: typer.Typer, get_container):
     @app.command()
     def sync(
         repos: Optional[str] = typer.Option(None, "--repos", help="Comma-separated repo names"),
+        no_passive: bool = typer.Option(
+            False, "--no-passive",
+            help="Skip refreshing passive worktrees (default: include).",
+        ),
     ):
         """Fast-forward repos that audit cleanly and are behind origin."""
         from mship.core.repo_state import audit_repos
@@ -46,4 +50,15 @@ def sync(
             else:
                 output.print(f"  [yellow]{r.name}[/yellow]: skipped ({r.message})")
 
+        if not no_passive:
+            from mship.core.repo_sync import refresh_passive_worktrees
+            passive_results = refresh_passive_worktrees(
+                container.state_manager(), config,
+            )
+            for r in passive_results:
+                if r.status == "fast_forwarded":
+                    output.print(f"  [green]{r.name}[/green]: {r.message}")
+                else:
+                    output.print(f"  [yellow]{r.name}[/yellow]: skipped ({r.message})")
+
         raise typer.Exit(code=1 if out.has_errors else 0)