Prevent repair from bypassing failed finish gate

Author: junsoo186

internal/app/commands.go

@@ -330,6 +330,10 @@ func statusHyper(fsys fsRoot, args []string) (commandOutput, *hyperError) {
 	}
 	state = refreshStateFromPlanForStatus(root, state)
 	derived := deriveCurrentGoalState(root, state.CurrentGoalID)
+	if failed, ok := failedFinishGateGoalState(root, state.CurrentGoalID); ok {
+		derived = failed
+		state.Status = "active"
+	}
 	runs, goals := statusDBCounts(root)
 	growth := growthStateForStatus(root)
 	readiness := readinessStateForStatus(root, growth)
@@ -508,6 +512,17 @@ func blockingActiveGoal(root string, state projectState) string {
 	if strings.TrimSpace(state.CurrentGoalID) == "" {
 		return ""
 	}
+	if failed, ok := failedFinishGateGoalState(root, state.CurrentGoalID); ok {
+		return strings.Join([]string{
+			"Current runtime packet has failed the finish gate: " + state.CurrentGoalID,
+			"Reason: " + failed.Reason,
+			"",
+			"Fix the same packet before creating another one:",
+			"  update " + filepath.Join(hyperDir, "goals", state.CurrentGoalID, "evidence.md"),
+			"  update " + filepath.Join(hyperDir, "goals", state.CurrentGoalID, "next.md"),
+			"  hyper complete",
+		}, "\n")
+	}
 	derived := deriveCurrentGoalState(root, state.CurrentGoalID)
 	if strings.TrimSpace(state.Status) != "" && strings.TrimSpace(derived.State) != "" && state.Status != "active" && state.Status != derived.State {
 		return strings.Join([]string{

internal/app/finish_gate.go

@@ -61,6 +61,26 @@ func runFinishGate(root string, state projectState, derived goalState, readiness
 	return result, nil
 }
 
+func failedFinishGateGoalState(root, goalID string) (goalState, bool) {
+	if strings.TrimSpace(goalID) == "" || finishGateReviewStatus(root, goalID) != "failed" {
+		return goalState{}, false
+	}
+	reviewPath := filepath.Join(hyperDir, "goals", goalID, "review.md")
+	return goalState{
+		State:  "active",
+		Reason: "Finish gate failed. Fix " + reviewPath + " findings, then run `hyper complete` again.",
+	}, true
+}
+
+func finishGateReviewStatus(root, goalID string) string {
+	body := readIfExists(filepath.Join(root, hyperDir, "goals", goalID, "review.md"))
+	return strings.ToLower(strings.TrimSpace(firstLabelValue(body, "Status")))
+}
+
+func isFailedFinishGateReason(reason string) bool {
+	return strings.Contains(strings.ToLower(strings.TrimSpace(reason)), "finish gate failed")
+}
+
 func readinessFinishGateFinding(state projectState, evidenceText string, readiness readinessState) string {
 	axis := strings.TrimSpace(readiness.NextPressure.Axis)
 	axisName := strings.TrimSpace(readiness.NextPressure.AxisName)

internal/app/main_test.go

@@ -620,6 +620,86 @@ func TestRunBlocksCompletedEvidenceBeforeFinishGate(t *testing.T) {
 	}
 }
 
+func TestRepairDoesNotBypassFailedFinishGate(t *testing.T) {
+	root := t.TempDir()
+	mustInitWithPlan(t, root, "Tiny notes", "Build a tiny notes MVP")
+	mustRun(t, root, "run")
+	writeFile(t, filepath.Join(root, ".hyper", "goals", "GOAL-0001", "evidence.md"), "# GOAL-0001 Evidence\n\n## Validation\n\n`go test ./...` passed.\n\n## Readiness Evidence\n\nCore UX: flow exists.\nValidation coverage: `go test ./...` passed and is repeatable.\n\n## Blocker\n\nNone blocking.\n")
+	writeFile(t, filepath.Join(root, ".hyper", "goals", "GOAL-0001", "next.md"), "# GOAL-0001 Next\n\n## Recommended Next Goal\n\nStart another packet.\n")
+
+	if _, err := runCLI(args("complete"), testRoot(root), fakeUpdater{}); err == nil {
+		t.Fatal("expected finish gate failure")
+	}
+	review := readFile(t, filepath.Join(root, ".hyper", "goals", "GOAL-0001", "review.md"))
+	assertContains(t, review, "Status: failed")
+	if status := finishGateReviewStatus(root, "GOAL-0001"); status != "failed" {
+		t.Fatalf("expected failed finish gate review status, got %q", status)
+	}
+	if _, ok := failedFinishGateGoalState(root, "GOAL-0001"); !ok {
+		t.Fatal("expected failed finish gate state to be visible")
+	}
+
+	status, err := runCLI(args("status", "--short"), testRoot(root), fakeUpdater{})
+	if err != nil {
+		t.Fatalf("status failed: %v", err)
+	}
+	assertContains(t, status.Stdout, "Finish gate failed")
+	assertNotContains(t, status.Stdout, "Next: hyper repair")
+
+	repair, err := runCLI(args("repair"), testRoot(root), fakeUpdater{})
+	if err != nil {
+		t.Fatalf("repair failed: %v", err)
+	}
+	assertContains(t, repair.Stdout, "State: no repair needed")
+	assertContains(t, repair.Stdout, "Finish gate failed")
+	state, hyperErr := readState(filepath.Join(root, ".hyper", "state.json"))
+	if hyperErr != nil {
+		t.Fatal(hyperErr)
+	}
+	if state.Status != "active" {
+		t.Fatalf("repair must not mark failed finish gate completed, got %s", state.Status)
+	}
+
+	_, err = runCLI(args("run", "Start another packet"), testRoot(root), fakeUpdater{})
+	if err == nil {
+		t.Fatal("expected failed finish gate to block another run")
+	}
+	assertContains(t, err.Message, "failed the finish gate")
+
+	state.Status = "completed"
+	if err := writeJSON(filepath.Join(root, ".hyper", "state.json"), state); err != nil {
+		t.Fatal(err)
+	}
+	status, err = runCLI(args("status", "--short"), testRoot(root), fakeUpdater{})
+	if err != nil {
+		t.Fatalf("status failed after legacy state write: %v", err)
+	}
+	assertContains(t, status.Stdout, "Finish gate failed")
+	assertNotContains(t, status.Stdout, "Next: hyper repair")
+	repair, err = runCLI(args("repair"), testRoot(root), fakeUpdater{})
+	if err != nil {
+		t.Fatalf("legacy repair failed: %v", err)
+	}
+	assertContains(t, repair.Stdout, "State: repaired")
+	assertContains(t, repair.Stdout, "To: active")
+	assertContains(t, repair.Stdout, "Next action: hyper complete")
+	nextPacket := readFile(t, filepath.Join(root, ".hyper", "next-packet.md"))
+	assertContains(t, nextPacket, "Action: complete-current")
+	assertContains(t, nextPacket, "Command: hyper complete")
+	state, hyperErr = readState(filepath.Join(root, ".hyper", "state.json"))
+	if hyperErr != nil {
+		t.Fatal(hyperErr)
+	}
+	if state.Status != "active" {
+		t.Fatalf("legacy failed finish gate repair must restore active state, got %s", state.Status)
+	}
+	_, err = runCLI(args("run", "Start another packet"), testRoot(root), fakeUpdater{})
+	if err == nil {
+		t.Fatal("expected failed finish gate to block another run even when state was marked completed")
+	}
+	assertContains(t, err.Message, "failed the finish gate")
+}
+
 func TestCompleteLearnsAndRefreshesReadiness(t *testing.T) {
 	root := t.TempDir()
 	mustInitWithPlan(t, root, "Tiny notes", "Build a tiny notes MVP")

internal/app/next_packet.go

@@ -14,6 +14,13 @@ type plannedNextPacket struct {
 }
 
 func buildNextPacketPlan(state projectState, derived goalState, readiness readinessState, growth growthState) plannedNextPacket {
+	if derived.State == "active" {
+		return plannedNextPacket{
+			Action:  "complete-current",
+			Command: "hyper complete",
+			Reason:  statusActionReason(state, derived, readiness, growth),
+		}
+	}
 	if state.AutoContinue && runUntilReached(state, readiness) {
 		return plannedNextPacket{
 			Action:   "stop",
@@ -89,6 +96,8 @@ func nextPacketGuard(plan plannedNextPacket) string {
 	switch plan.Action {
 	case "advance":
 		return "Do not run `hyper advance` unless the user accepts the stage change."
+	case "complete-current":
+		return "Do not create a new runtime packet; fix the current packet evidence, next notes, and review findings before running `hyper complete`."
 	case "run":
 		return "Create the next runtime packet only after the current packet has passed the finish gate and completed."
 	case "stop":

internal/app/repair.go

@@ -30,6 +30,22 @@ func currentStateConsistency(root string, state projectState) stateConsistency {
 		}
 	}
 	derived := deriveCurrentGoalState(root, goalID)
+	if failed, ok := failedFinishGateGoalState(root, goalID); ok {
+		consistent := projectStatus == "" || projectStatus == "active"
+		reason := failed.Reason
+		if !consistent {
+			reason = fmt.Sprintf("state.json says %s, but the finish gate failed; restore %s to active before continuing.", projectStatus, goalID)
+		}
+		return stateConsistency{
+			HasState:      true,
+			HasGoal:       true,
+			ProjectStatus: projectStatus,
+			Derived:       failed,
+			Consistent:    consistent,
+			Repairable:    !consistent,
+			Reason:        reason,
+		}
+	}
 	consistent := projectStatus == "" || projectStatus == derived.State
 	repairable := !consistent && derived.State != "active"
 	reason := "state.json matches the current runtime packet."

internal/app/status.go

@@ -304,6 +304,9 @@ func statusActionReasonWithRefresh(state projectState, derived goalState, readin
 		return "Project state needs refresh before trusting the next action: " + refresh.Reason
 	}
 	if derived.State == "active" {
+		if isFailedFinishGateReason(derived.Reason) {
+			return derived.Reason
+		}
 		return "The current runtime packet is still open; evidence and next.md decide what the project learns."
 	}
 	if strings.TrimSpace(state.Status) != "" && strings.TrimSpace(state.Status) != strings.TrimSpace(derived.State) {
@@ -333,6 +336,9 @@ func statusDoNotDoYetWithRefresh(state projectState, derived goalState, readines
 		return "Do not advance or start another packet until `hyper migrate` refreshes growth and readiness state."
 	}
 	if derived.State == "active" {
+		if isFailedFinishGateReason(derived.Reason) {
+			return "Do not start another `hyper run`; fix review.md findings in the same packet and run `hyper complete` again."
+		}
 		return "Do not start another `hyper run` until this packet is completed or blocked."
 	}
 	if strings.TrimSpace(state.Status) != "" && strings.TrimSpace(state.Status) != strings.TrimSpace(derived.State) {