fix: prompt_sync helpers push the current branch, not a hardcoded main

[Jammy2211]

Summary

The PyAutoMind half of PyAutoBrain#225, plus the Mind bookkeeping for PyAutoBrain#223/#224 that this session produced. Both are on this branch because the session was scoped to it; see "Scope note" below.

The defect — corrected after measurement

scripts/prompt_sync.sh — both helpers ended in git push origin main regardless of what was checked out:

prompt_sync_push() {
  ...
  git commit -m "$subject" && \
  git push origin main )
}

create_issue step 6 and start_dev step 7 both instruct an agent to call it.

An earlier revision of this PR described this as "pushes Mind straight to main". That was half right, and not the half that fires most often. git push origin main pushes the local main ref — never the commit just made on a feature branch. Measured against real bare remotes, the old behaviour splits by the state of local main:

local main vs remote	what the old script did
equal — the normal case, a session that branched from it	push is a no-op, exits 0, and the committed work never leaves the machine. The caller is told the sync succeeded.
ahead — unpushed commits on main	publishes those to remote main, unreviewed, and still leaves the branch work local.

The first row is the common one and the quieter danger: in an ephemeral cloud container, "committed, reported synced, never pushed" is silent loss. The second is the review bypass. Same root cause; both fixed by pushing HEAD.

The single-branch laptop flow is byte-identical — there the current branch is main. Verified across four scenarios (nothing staged, tracked change, untracked-only, deletion): old and new produce the same commit count, same refs, same remote state. A detached HEAD is now refused rather than guessed at.

One regression caught while fixing it

prompt_sync_push is restructured to drop its subshell. With the naive ( ... ) && _push shape, the documented "no-op if nothing is staged" early return falls through to the push, so a caller with no changes would push anyway. The early return now precedes the push, and test_push_is_still_a_no_op_when_nothing_is_staged pins it.

Test Plan

• pytest tests/ — 134 passed (127 existing + 7 new)
• python3 scripts/lifecycle.py check — OK
• 5 of the 7 new tests fail against origin/main's script, verified by swapping it in. A test that cannot fail is decoration.
• Old vs new behaviour on main compared directly across 4 scenarios — identical

The tests drive the real script against throwaway git repos with real bare remotes, because that is the only way to observe which ref actually moved; grepping the source for the string would pass on a script that still pushed the wrong branch by another route.

The two halves of the bug get their own tests, since they are separate failures: test_committed_work_actually_reaches_the_remote and test_a_branch_push_never_advances_main.

The most striking pre-fix failure: from a detached HEAD, the old script pushed main -> main.

Scope note — why this branch carries two things

The session was scoped to claude/automind-task-planning-wxq004, so all Mind changes landed here. Alongside the fix, the branch carries the registry bookkeeping for the tasks that produced it — filing PyAutoBrain#223/#225, the draft/ → active/ lifecycle moves, and the active.md entries.

That bookkeeping is ordinary Mind state and should land regardless. If you would rather review the fix in isolation, say so and I will split the scripts/ + tests/ changes onto their own branch.

Related

• PyAutoBrain#225 — umbrella for all three defects; stays open until this and PyAutoBrain#226 both land
• PyAutoBrain#226 — the other two defects (conflict guard fails closed; installer tests unpinned). CI green on both legs.
• PyAutoBrain#224 — the task during which all three were hit