diff --git a/doGui.go b/doGui.go
index d7a31c3..c274138 100644
--- a/doGui.go
+++ b/doGui.go
@@ -175,11 +175,16 @@ func drawWindow(win *gadgets.GenericWindow) {
 	})
 
 	var patchesWin *stdPatchTableWin
-	gridM.NewButton("Your patches", func() {
+	var patchButton *gui.Node
+	patchButton = gridM.NewButton("Your patches", func() {
 		if patchesWin != nil {
 			patchesWin.Toggle()
 			return
 		}
+		if !isPatchingSafe() {
+			patchButton.SetLabel("not safe yet")
+			return
+		}
 		// patchesWin = makePatchesWin(me.forge.Patchsets)
 		notdone := new(forgepb.Patches)
 
diff --git a/doNormal.go b/doNormal.go
index 25d766f..9af2cdf 100644
--- a/doNormal.go
+++ b/doNormal.go
@@ -33,6 +33,10 @@ func doNormal() bool {
 	}
 	if count > 0 {
 		log.Info("Some repos are not in a 'normal' state. error count =", count)
+		log.Info("TODO: list the repos here. forge patch repos?")
+		configSave = false
+		me.forge.SetConfigSave(false)
+		dumpDirtyRepos()
 		return false
 	}
 	return true
diff --git a/doPatch.go b/doPatch.go
index d80723c..4e456f1 100644
--- a/doPatch.go
+++ b/doPatch.go
@@ -27,10 +27,21 @@ func doPatchInit() {
 	}
 }
 
+func isPatchingSafe() bool {
+	if me.forge.Config.Mode == forgepb.ForgeMode_NORMAL {
+		return true
+	}
+	log.Info("forge requres a 'normal' state to work with patches")
+	log.Info("you must run:")
+	log.Info("")
+	log.Info("forge normal")
+	log.Info("")
+	return false
+}
+
 func doPatch() error {
-	if me.forge.Config.Mode != forgepb.ForgeMode_NORMAL {
-		log.Info("forge requres a 'normal' state to work with patches")
-		return log.Errorf("not in 'normal' forge state")
+	if !isPatchingSafe() {
+		return log.Errorf("not safe to work on patches")
 	}
 
 	if argv.Patch.Submit != nil {
@@ -194,12 +205,12 @@ func IsValidPatch(p *forgepb.Patch) bool {
 		log.Info("can not apply patch! repo not found", basepath, filename)
 		return false
 	}
-	if repo.DevelHash() != p.StartHash {
+	if repo.ActualDevelHash() != p.StartHash {
 		log.Info("can not apply patch! devel hash mismatch", basepath, filename)
 		return false
 	}
-	if repo.DevelHash() == p.StartHash {
-		log.Info("local devel hash:", repo.DevelHash(), "matches patch hash", p.StartHash, "and can be applied")
+	if repo.ActualDevelHash() == p.StartHash {
+		log.Info("local devel hash:", repo.ActualDevelHash(), "matches patch hash", p.StartHash, "and can be applied")
 	}
 	log.Info("start:", p.StartHash, "end:", p.CommitHash, "file:", basepath, filename, "devel version", repo.GetDevelVersion())
 	for _, line := range p.Files {
diff --git a/doPull.go b/doPull.go
index 029a9e1..bacaf8e 100644
--- a/doPull.go
+++ b/doPull.go
@@ -4,156 +4,38 @@
 package main
 
 import (
-	"fmt"
-	"time"
-
-	"go.wit.com/lib/gui/shell"
+	"go.wit.com/lib/protobuf/forgepb"
 	"go.wit.com/lib/protobuf/gitpb"
 	"go.wit.com/log"
 )
 
-func rillPull(repo *gitpb.Repo) error {
-	if repo.IsDirty() {
-		// never do dirty repos
-		return nil
-	}
-	t, _ := repo.LastGitPull()
-	if time.Since(t) < time.Minute*10 && !argv.Force {
-		if argv.Verbose {
-			log.Info(repo.GetFullPath(), "git pulled too recently", shell.FormatDuration(time.Since(t)))
-		}
-		return nil
-	}
-	cur := repo.GetCurrentBranchName()
-	if !repo.IsBranchRemote(cur) {
-		if argv.Verbose {
-			log.Info(repo.GetFullPath(), "branch is not remote", cur)
-		}
-		return nil
-	}
-
-	var cmd []string
-	cmd = append(cmd, "git", "pull")
-	err := repo.RunVerbose(cmd)
-	if err != nil {
-		log.Info(repo.GetFullPath(), "git pull err:", err)
-	}
-	return nil
-}
-
 // is every repo on the devel branch?
-
 func doGitPull() error {
-	if argv.Pull == nil {
-		return fmt.Errorf("not really 'fetch pull'")
-	}
-
-	if argv.Force {
-		now := time.Now()
-		stats := me.forge.RillFuncError(rillPull)
-		count := me.forge.RillReload()
-		if count != 0 {
-			me.forge.ConfigSave()
+	if me.forge.Config.Mode != forgepb.ForgeMode_MASTER {
+		if argv.Force == true {
+			log.Info("okay. you have forced the issue")
+		} else {
+			log.Info("forge requres being on the master branch")
+			log.Info("you must run:")
+			log.Info("")
+			log.Info("forge checkout master")
+			log.Info("")
+			return nil
 		}
-
-		total, count, nope, _ := me.forge.IsEverythingOnMaster()
-		log.Printf("Master branch check. %d total repos. (%d git pulled) (%d not on master branch) (%s) git pull total=FIXME%d\n", total, count, nope, shell.FormatDuration(time.Since(now)), len(stats))
-		return nil
 	}
 
-	check := gitpb.NewRepos()
-
-	if argv.Pull.Dirty != nil {
-		check = me.forge.FindDirty()
-	}
-
-	if argv.Pull.Patches != nil {
-		check = findReposWithPatches()
-	}
-
-	if argv.Pull.Check != nil {
-		// TODO: never wrote this yet
-		// update, err := me.forge.CheckVersions()
-		// return err
-		return nil
-	}
-
-	if check.Len() == 0 {
-		// check = doFind()
-		check = findAll()
-		// check = find50()
-		// check = findMine()
-	}
-
-	me.forge.PrintHumanTableFull(check)
-	if argv.Pull.Dirty != nil {
-		log.Info("dirty count =", check.Len())
-		return nil
-	}
-
-	found, err := me.forge.LookupPB(check)
-	if err != nil {
-		log.Info("LookupPB() failed", err, "len(check)=", check.Len())
-		return err
-	}
-	// me.forge.PrintHumanTableFull(found)
-
-	// check to see if the repos need to be updated
-	update := gitpb.NewRepos()
-
-	if found.Len() == 0 {
-		return nil
-	}
-	log.Info("found.Len() ==", found.Len())
-
-	for repo := range found.IterAll() {
-		masterb := repo.GetMasterBranchName()
-		if masterb == "" {
-			log.Info(repo.GetNamespace(), "master branch blank")
-			continue
-		}
-		a := repo.GetLocalHash(masterb)
-		ns := repo.GetNamespace()
-		repo2 := me.forge.Repos.FindByNamespace(ns)
-		if repo2 == nil {
-			log.Info("repo namespace does not exist", a, repo.Namespace)
-			continue
-		}
-		b := repo2.GetLocalHash(repo2.GetMasterBranchName())
-		if b == a {
-			continue
-		}
-		log.Info(a, "!=", b, repo.Namespace)
-		update.AppendByNamespace(repo2)
-	}
-	if update.Len() == 0 {
-		// nothing to update
-		return nil
-	}
-	if _, err := me.forge.UpdatePB(update); err != nil {
-		log.Info("UpdatePB() failed", err, "len(check)=", update.Len())
-		return err
+	// stats := me.forge.RillFuncError(rillPull)
+	log.Info("TODO: actually git pull here? this is a bad idea. stopping.")
+	submit := gitpb.NewRepos()
+	for repo := range me.forge.Repos.IterByFullPath() {
+		newrepo := new(gitpb.Repo)
+		newrepo.MasterHash = repo.MasterHash
+		newrepo.DevelHash = repo.DevelHash
+		newrepo.Namespace = repo.Namespace
+		newrepo.URL = repo.URL
+		submit.Append(newrepo)
 	}
+	submit.HttpPost(myServer(), "check")
 	return nil
 
 }
-
-// git fetch origin master:master
-func rillFetchMaster(repo *gitpb.Repo) error {
-	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
-		// only fetch when branch is on the user branch
-		return nil
-	}
-	branch := repo.GetMasterBranchName()
-	cmd := []string{"git", "fetch", "origin", branch + ":" + branch}
-	err := repo.RunVerbose(cmd)
-	return err
-}
-
-func doGitFetch() {
-	me.forge.RillFuncError(rillFetchMaster)
-	count := me.forge.RillReload()
-	if count != 0 {
-		me.forge.ConfigSave()
-	}
-}
diff --git a/doPullOld.go b/doPullOld.go
new file mode 100644
index 0000000..fc0ef18
--- /dev/null
+++ b/doPullOld.go
@@ -0,0 +1,55 @@
+// Copyright 2017-2025 WIT.COM Inc. All rights reserved.
+// Use of this source code is governed by the GPL 3.0
+
+package main
+
+/*
+func rillPull(repo *gitpb.Repo) error {
+	if repo.IsDirty() {
+		// never do dirty repos
+		return nil
+	}
+	t, _ := repo.LastGitPull()
+	if time.Since(t) < time.Minute*10 && !argv.Force {
+		if argv.Verbose {
+			log.Info(repo.GetFullPath(), "git pulled too recently", shell.FormatDuration(time.Since(t)))
+		}
+		return nil
+	}
+	cur := repo.GetCurrentBranchName()
+	if !repo.IsBranchRemote(cur) {
+		if argv.Verbose {
+			log.Info(repo.GetFullPath(), "branch is not remote", cur)
+		}
+		return nil
+	}
+
+	var cmd []string
+	cmd = append(cmd, "git", "pull")
+	err := repo.RunVerbose(cmd)
+	if err != nil {
+		log.Info(repo.GetFullPath(), "git pull err:", err)
+	}
+	return nil
+}
+
+// git fetch origin master:master
+func rillFetchMaster(repo *gitpb.Repo) error {
+	if repo.GetCurrentBranchName() != repo.GetUserBranchName() {
+		// only fetch when branch is on the user branch
+		return nil
+	}
+	branch := repo.GetMasterBranchName()
+	cmd := []string{"git", "fetch", "origin", branch + ":" + branch}
+	err := repo.RunVerbose(cmd)
+	return err
+}
+
+func doGitFetch() {
+	me.forge.RillFuncError(rillFetchMaster)
+	count := me.forge.RillReload()
+	if count != 0 {
+		me.forge.ConfigSave()
+	}
+}
+*/
diff --git a/main.go b/main.go
index 8a8f2c4..5227630 100644
--- a/main.go
+++ b/main.go
@@ -186,11 +186,6 @@ func main() {
 		okExit("")
 	}
 
-	if argv.GitFetch != nil {
-		doGitFetch()
-		okExit("")
-	}
-
 	if argv.Merge != nil {
 		if argv.Merge.Devel != nil {
 			start := time.Now()