fix(run): address gadfly review of the checkpoint PR

Real findings from the consensus review (44 raw; heavy devstral noise):

- finalizeCheckpoint is now fired from the top-of-Run defer, so it runs on
  EVERY exit: a panic, an early build-error return (before the run loop), AND
  normal completion. Previously an early return on a recovered run left its
  durable record unfinalized → boot recovery would retry it forever on a
  persistent build error. (opus + glm)
- Removed the dead ActivePhase field from run.RunCheckpointState +
  run.ResumeState (and the battery RunCheckpoint) — phase recovery is
  boundary-granular (skip completed phases; the interrupted phase re-runs from
  its start), so ActivePhase was never written nor read. Docs across
  ports/checkpoint/phases now state this plainly (5-model consensus that the
  field + docs over-promised mid-phase resume).
- CheckpointerFactory.Begin error is now logged (WARN) before degrading to
  non-durable, per the documented contract (was silently swallowed). (4 models)
- finalizeCheckpoint logs Complete/Fail errors (was silent).
- Resume phase-skip now keys off a SEPARATE resumeSkip set, not the live
  outputs map — a fresh run with two same-named phases no longer skips the
  second (the outputs map fills as phases run). (opus:max) + regression test.
- Removed the dead checkpoint.factory.now field (never set). (opus + glm)
- Fixed the stale phaseDeps doc (the step observer moved out of sharedOpts to
  per-path). Hoisted the resume guard to a local; dropped the wasted acc
  allocation on the resume path; documented that Save throttling is the
  Checkpointer's responsibility and the accumulated transcript is pre-compaction
  (host size-caps it).

Note (carried from the PR): classifyCheckpointOutcome keys shutdown on
run.ErrShutdown; mort stamps its own runengine.ErrShutdown — the mort wiring PR
aliases them so errors.Is matches.

New test: duplicate phase names both run on a fresh run. Full ./... green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

run/checkpoint.go

@@ -3,6 +3,7 @@ package run
 import (
 	"context"
 	"errors"
+	"log/slog"
 
 	"gitea.stevedudenhoeffer.com/steve/majordomo/llm"
 )
@@ -17,12 +18,14 @@ import (
 
 // ResumeState carries a recovered run's prior progress into Run so the run
 // continues instead of restarting. The host's recovery path sets it via
-// WithResumeState; the executor reads it (single-loop seeds the saved transcript
-// as history; multi-phase skips completed phases and seeds the active phase).
+// WithResumeState; the executor reads it:
+//   - single-loop: History seeds the saved transcript (the run continues).
+//   - multi-phase: CompletedPhases are skipped; the interrupted phase re-runs
+//     from its start (boundary-granular — there is no mid-phase transcript
+//     resume, so History is unused for multi-phase runs).
 type ResumeState struct {
-	History         []llm.Message // single-loop transcript OR active-phase transcript
+	History         []llm.Message // single-loop transcript (unused for multi-phase)
 	CompletedPhases []PhaseOutput // multi-phase: outputs of finished phases, in order
-	ActivePhase     string        // multi-phase: the phase that was in flight
 }
 
 type resumeStateKey struct{}
@@ -79,15 +82,21 @@ func classifyCheckpointOutcome(runErr, cause error) checkpointOutcome {
 
 // finalizeCheckpoint applies the outcome to the per-run checkpointer (nil-safe).
 // Runs on a detached context so a cancelled run still records its terminal state.
+// Complete/Fail errors are best-effort but logged (a stale record would only
+// cause a wasteful boot-recovery retry, not data loss).
 func finalizeCheckpoint(ctx context.Context, cp Checkpointer, runErr error, cause error) {
 	if cp == nil {
 		return
 	}
 	switch classifyCheckpointOutcome(runErr, cause) {
 	case checkpointComplete:
-		_ = cp.Complete(detach(ctx))
+		if err := cp.Complete(detach(ctx)); err != nil {
+			slog.Warn("run: checkpoint Complete failed", "error", err)
+		}
 	case checkpointFail:
-		_ = cp.Fail(detach(ctx), runErr)
+		if err := cp.Fail(detach(ctx), runErr); err != nil {
+			slog.Warn("run: checkpoint Fail failed", "error", err)
+		}
 	case checkpointLeaveRunning:
 		// Interrupted by shutdown: leave the record for boot recovery.
 	}