feat: skip witness/refinery registration for owned+direct convoys (gt-myofa.5)

Polecats working on owned convoys with direct merge strategy now bypass the
standard witness/refinery merge pipeline. The polecat already pushed to main,
so no MR is needed.

Changes:
- gt done: skip MR creation for owned+direct convoys, close issue directly
- gt done: include convoy info (ID, owned, strategy) in POLECAT_DONE body
- witness: HandlePolecatDone skips merge flow for owned+direct, runs cleanup
- refinery: belt-and-suspenders checks in handler and engineer to skip strays
- protocol: add PolecatDonePayload with SkipMergeFlow() and parser

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: steveyegge

internal/cmd/done.go

@@ -380,7 +380,7 @@ func runDone(cmd *cobra.Command, args []string) (retErr error) {
 	var mrID string
 	var pushFailed bool
 	var doneErrors []string
-	var mergeStrategy string // convoy merge strategy: "direct", "mr", "local", or "" (default mr)
+	var convoyInfo *ConvoyInfo // Populated if issue is tracked by a convoy
 	if exitType == ExitCompleted {
 		if branch == defaultBranch || branch == "master" {
 			return fmt.Errorf("cannot submit %s/master branch to merge queue", defaultBranch)
@@ -477,10 +477,10 @@ func runDone(cmd *cobra.Command, args []string) (retErr error) {
 		//   direct: push commits straight to target branch, bypass refinery
 		//   mr:     default — create merge-request bead, refinery merges
 		//   local:  keep on feature branch, no push, no MR (for human review/upstream PRs)
-		mergeStrategy = getConvoyMergeStrategyForIssue(issueID)
+		convoyInfo = getConvoyInfoForIssue(issueID)
 
 		// Handle "local" strategy: skip push and MR entirely
-		if mergeStrategy == "local" {
+		if convoyInfo != nil && convoyInfo.MergeStrategy == "local" {
 			fmt.Printf("%s Local merge strategy: skipping push and merge queue\n", style.Bold.Render("→"))
 			fmt.Printf("  Branch: %s\n", branch)
 			if issueID != "" {
@@ -492,7 +492,7 @@ func runDone(cmd *cobra.Command, args []string) (retErr error) {
 		}
 
 		// Handle "direct" strategy: push to target branch, skip MR
-		if mergeStrategy == "direct" {
+		if convoyInfo != nil && convoyInfo.MergeStrategy == "direct" {
 			fmt.Printf("%s Direct merge strategy: pushing to %s\n", style.Bold.Render("→"), defaultBranch)
 			directRefspec := branch + ":" + defaultBranch
 			directPushErr := g.Push("origin", directRefspec, false)
@@ -664,6 +664,39 @@ func runDone(cmd *cobra.Command, args []string) (retErr error) {
 			}
 		}
 
+		// Check if issue belongs to an owned+direct convoy.
+		// Owned convoys with direct merge strategy bypass the refinery pipeline —
+		// the polecat already pushed to main. Skip MR creation and close directly.
+		convoyInfo = getConvoyInfoForIssue(issueID)
+		if convoyInfo.IsOwnedDirect() {
+			fmt.Printf("%s Owned convoy (direct merge): skipping merge queue\n", style.Bold.Render("→"))
+			fmt.Printf("  Convoy: %s\n", convoyInfo.ID)
+			fmt.Printf("  Branch: %s\n", branch)
+			fmt.Printf("  Issue: %s\n", issueID)
+			fmt.Println()
+			fmt.Printf("%s\n", style.Dim.Render("Polecat already pushed to main. No MR needed."))
+
+			// Close the issue directly — refinery won't process it.
+			// Retry with backoff handles transient dolt lock contention.
+			var closeErr error
+			for attempt := 1; attempt <= 3; attempt++ {
+				closeErr = bd.ForceCloseWithReason("Completed via owned+direct convoy (no MR needed)", issueID)
+				if closeErr == nil {
+					fmt.Printf("%s Issue %s closed (owned+direct)\n", style.Bold.Render("✓"), issueID)
+					break
+				}
+				if attempt < 3 {
+					style.PrintWarning("close attempt %d/3 failed: %v (retrying in %ds)", attempt, closeErr, attempt*2)
+					time.Sleep(time.Duration(attempt*2) * time.Second)
+				}
+			}
+			if closeErr != nil {
+				style.PrintWarning("could not close issue %s after 3 attempts: %v", issueID, closeErr)
+			}
+
+			goto notifyWitness
+		}
+
 		// Determine target branch (auto-detect integration branch if applicable)
 		// Only if refinery integration branch auto-targeting is enabled
 		target := defaultBranch
@@ -857,8 +890,15 @@ afterDoltMerge:
 		bodyLines = append(bodyLines, fmt.Sprintf("Gate: %s", doneGate))
 	}
 	bodyLines = append(bodyLines, fmt.Sprintf("Branch: %s", branch))
-	if mergeStrategy != "" && mergeStrategy != "mr" {
-		bodyLines = append(bodyLines, fmt.Sprintf("MergeStrategy: %s", mergeStrategy))
+	// Include convoy ownership info so witness can skip merge flow registration
+	if convoyInfo != nil {
+		bodyLines = append(bodyLines, fmt.Sprintf("ConvoyID: %s", convoyInfo.ID))
+		if convoyInfo.Owned {
+			bodyLines = append(bodyLines, "ConvoyOwned: true")
+		}
+		if convoyInfo.MergeStrategy != "" {
+			bodyLines = append(bodyLines, fmt.Sprintf("MergeStrategy: %s", convoyInfo.MergeStrategy))
+		}
 	}
 	if len(doneErrors) > 0 {
 		bodyLines = append(bodyLines, fmt.Sprintf("Errors: %s", strings.Join(doneErrors, "; ")))

internal/cmd/sling_convoy.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"bytes"
 	"crypto/rand"
 	"encoding/base32"
 	"encoding/json"
@@ -136,40 +137,65 @@ func convoyTracksBead(beadsDir, convoyID, beadID string) bool {
 	return false
 }
 
-// getConvoyMergeStrategyForIssue finds the convoy tracking the given issue
-// and returns its merge strategy ("direct", "mr", "local", or "" for default/mr).
-// Returns "" on any error (convoy not found, lookup fails, no strategy set).
-func getConvoyMergeStrategyForIssue(issueID string) string {
-	if issueID == "" {
-		return ""
-	}
+// ConvoyInfo holds convoy details for an issue's tracking convoy.
+type ConvoyInfo struct {
+	ID            string // Convoy bead ID (e.g., "hq-cv-abc")
+	Owned         bool   // true if convoy has gt:owned label
+	MergeStrategy string // "direct", "mr", "local", or "" (default = mr)
+}
+
+// IsOwnedDirect returns true if the convoy is owned with direct merge strategy.
+// This is the key check for skipping witness/refinery merge pipeline.
+func (c *ConvoyInfo) IsOwnedDirect() bool {
+	return c != nil && c.Owned && c.MergeStrategy == "direct"
+}
+
+// getConvoyInfoForIssue checks if an issue is tracked by a convoy and returns its info.
+// Returns nil if not tracked by any convoy.
+func getConvoyInfoForIssue(issueID string) *ConvoyInfo {
 	convoyID := isTrackedByConvoy(issueID)
 	if convoyID == "" {
-		return ""
+		return nil
 	}
 
 	townRoot, err := workspace.FindFromCwd()
 	if err != nil {
-		return ""
+		return nil
 	}
 	townBeads := filepath.Join(townRoot, ".beads")
 
+	// Get convoy details (labels + description) for ownership and merge strategy
 	showCmd := exec.Command("bd", "show", convoyID, "--json")
 	showCmd.Dir = townBeads
+	var stdout bytes.Buffer
+	showCmd.Stdout = &stdout
 
-	out, err := showCmd.Output()
-	if err != nil {
-		return ""
+	if err := showCmd.Run(); err != nil {
+		return &ConvoyInfo{ID: convoyID} // Return basic info even if details fail
 	}
 
 	var convoys []struct {
-		Description string `json:"description"`
+		Labels      []string `json:"labels"`
+		Description string   `json:"description"`
 	}
-	if err := json.Unmarshal(out, &convoys); err != nil || len(convoys) == 0 {
-		return ""
+	if err := json.Unmarshal(stdout.Bytes(), &convoys); err != nil || len(convoys) == 0 {
+		return &ConvoyInfo{ID: convoyID}
+	}
+
+	info := &ConvoyInfo{ID: convoyID}
+
+	// Check for gt:owned label
+	for _, label := range convoys[0].Labels {
+		if label == "gt:owned" {
+			info.Owned = true
+			break
+		}
 	}
 
-	return parseConvoyMergeStrategy(convoys[0].Description)
+	// Parse merge strategy from description
+	info.MergeStrategy = parseConvoyMergeStrategy(convoys[0].Description)
+
+	return info
 }
 
 // createAutoConvoy creates an auto-convoy for a single issue and tracks it.

internal/protocol/messages.go

@@ -333,6 +333,28 @@ func ParseReworkRequestPayload(body string) (*ReworkRequestPayload, error) {
 	return payload, nil
 }
 
+// ParsePolecatDonePayload parses a POLECAT_DONE notification body.
+// Unlike formal protocol messages, POLECAT_DONE is a mail convention — no
+// required fields are enforced. Returns a best-effort parse of available fields.
+func ParsePolecatDonePayload(polecatName, body string) *PolecatDonePayload {
+	payload := &PolecatDonePayload{
+		Polecat:       polecatName,
+		ExitType:      parseField(body, "Exit"),
+		Issue:         parseField(body, "Issue"),
+		Branch:        parseField(body, "Branch"),
+		MR:            parseField(body, "MR"),
+		ConvoyID:      parseField(body, "ConvoyID"),
+		MergeStrategy: parseField(body, "MergeStrategy"),
+		Errors:        parseField(body, "Errors"),
+	}
+
+	if parseField(body, "ConvoyOwned") == "true" {
+		payload.ConvoyOwned = true
+	}
+
+	return payload
+}
+
 // parseField extracts a field value from a key-value body format.
 // Format: "Key: value"
 func parseField(body, key string) string {

internal/protocol/refinery_handlers.go

@@ -43,6 +43,10 @@ func (h *DefaultRefineryHandler) SetOutput(w io.Writer) {
 // HandleMergeReady handles a MERGE_READY message from Witness.
 // When a polecat's work is verified and ready, the Refinery acknowledges receipt.
 //
+// Belt-and-suspenders: if the message indicates this is from an owned+direct
+// convoy, the Refinery skips processing. These MRs shouldn't exist (gt done
+// skips MR creation for owned+direct), but this guards against edge cases.
+//
 // NOTE: The merge-request bead is created by `gt done`, so we no longer need
 // to add to the mrqueue here. The Refinery queries beads directly for ready MRs.
 func (h *DefaultRefineryHandler) HandleMergeReady(payload *MergeReadyPayload) error {
@@ -51,6 +55,13 @@ func (h *DefaultRefineryHandler) HandleMergeReady(payload *MergeReadyPayload) er
 	_, _ = fmt.Fprintf(h.Output, "  Issue: %s\n", payload.Issue)
 	_, _ = fmt.Fprintf(h.Output, "  Verified: %s\n", payload.Verified)
 
+	// Belt-and-suspenders: check if this is from an owned+direct convoy.
+	// The Verified field may contain "owned+direct" marker from witness.
+	if payload.Verified == "owned+direct: skip merge" {
+		_, _ = fmt.Fprintf(h.Output, "[Refinery] ⚠ Owned+direct convoy — skipping merge (belt-and-suspenders)\n")
+		return nil
+	}
+
 	// The merge-request bead is created by `gt done` with gt:merge-request label.
 	// The Refinery queries beads directly via ReadyWithType("merge-request").
 	// No need to add to mrqueue - that was a duplicate tracking file.

internal/protocol/types.go

@@ -166,6 +166,44 @@ type ReworkRequestPayload struct {
 	Instructions string `json:"instructions,omitempty"`
 }
 
+// PolecatDonePayload contains the data from a POLECAT_DONE notification.
+// This is not a formal protocol message (it's a mail convention), but the
+// payload is structured for programmatic parsing by witness handlers.
+type PolecatDonePayload struct {
+	// Polecat is the worker name.
+	Polecat string `json:"polecat"`
+
+	// ExitType is the exit status (COMPLETED, ESCALATED, DEFERRED, PHASE_COMPLETE).
+	ExitType string `json:"exit_type"`
+
+	// Issue is the beads issue ID the polecat worked on.
+	Issue string `json:"issue,omitempty"`
+
+	// Branch is the polecat's work branch.
+	Branch string `json:"branch"`
+
+	// MR is the merge-request bead ID (empty for owned+direct convoys).
+	MR string `json:"mr,omitempty"`
+
+	// ConvoyID is the tracking convoy ID (if any).
+	ConvoyID string `json:"convoy_id,omitempty"`
+
+	// ConvoyOwned indicates the convoy has caller-managed lifecycle.
+	ConvoyOwned bool `json:"convoy_owned,omitempty"`
+
+	// MergeStrategy is the convoy's merge strategy (direct, mr, local).
+	MergeStrategy string `json:"merge_strategy,omitempty"`
+
+	// Errors contains any non-fatal errors encountered during gt done.
+	Errors string `json:"errors,omitempty"`
+}
+
+// SkipMergeFlow returns true if this polecat's work should bypass the
+// standard witness/refinery merge pipeline (owned convoy + direct merge).
+func (p *PolecatDonePayload) SkipMergeFlow() bool {
+	return p.ConvoyOwned && p.MergeStrategy == "direct"
+}
+
 // IsProtocolMessage returns true if the subject matches a known protocol type.
 func IsProtocolMessage(subject string) bool {
 	return ParseMessageType(subject) != ""

internal/protocol/witness_handlers.go

@@ -100,6 +100,49 @@ func (h *DefaultWitnessHandler) HandleMergeFailed(payload *MergeFailedPayload) e
 	return nil
 }
 
+// HandlePolecatDone handles a POLECAT_DONE notification.
+// When a polecat signals completion, the Witness decides whether to register
+// the work for merge processing or skip it (for owned+direct convoys).
+//
+// For standard convoys: the merge pipeline proceeds normally (MR bead exists,
+// refinery will process it).
+//
+// For owned+direct convoys: the polecat already pushed to main and closed its
+// issue. The witness skips merge flow registration — only cleanup remains.
+func (h *DefaultWitnessHandler) HandlePolecatDone(payload *PolecatDonePayload) error {
+	_, _ = fmt.Fprintf(h.Output, "[Witness] POLECAT_DONE received for polecat %s\n", payload.Polecat)
+	_, _ = fmt.Fprintf(h.Output, "  Exit: %s\n", payload.ExitType)
+	if payload.Issue != "" {
+		_, _ = fmt.Fprintf(h.Output, "  Issue: %s\n", payload.Issue)
+	}
+	_, _ = fmt.Fprintf(h.Output, "  Branch: %s\n", payload.Branch)
+
+	if payload.SkipMergeFlow() {
+		_, _ = fmt.Fprintf(h.Output, "[Witness] ✓ Owned+direct convoy %s — merge flow skipped\n", payload.ConvoyID)
+		_, _ = fmt.Fprintf(h.Output, "  Polecat already pushed to main. Proceeding with cleanup only.\n")
+
+		// Initiate polecat cleanup (same as HandleMerged)
+		nukeResult := witness.AutoNukeIfClean(h.WorkDir, h.Rig, payload.Polecat)
+		if nukeResult.Nuked {
+			fmt.Fprintf(h.Output, "[Witness] ✓ Auto-nuked polecat %s: %s\n", payload.Polecat, nukeResult.Reason)
+		} else if nukeResult.Skipped {
+			fmt.Fprintf(h.Output, "[Witness] ⚠ Cleanup skipped for %s: %s\n", payload.Polecat, nukeResult.Reason)
+		} else if nukeResult.Error != nil {
+			fmt.Fprintf(h.Output, "[Witness] ✗ Cleanup failed for %s: %v\n", payload.Polecat, nukeResult.Error)
+		}
+
+		return nil
+	}
+
+	// Standard flow: log receipt, merge pipeline will handle the rest
+	if payload.MR != "" {
+		_, _ = fmt.Fprintf(h.Output, "  MR: %s\n", payload.MR)
+	}
+	_, _ = fmt.Fprintf(h.Output, "[Witness] ✓ Standard flow — Refinery will process MR\n")
+
+	return nil
+}
+
 // HandleReworkRequest handles a REWORK_REQUEST message from Refinery.
 // When a branch has conflicts requiring rebase, the Witness:
 // 1. Logs the conflict

internal/refinery/engineer.go

@@ -1008,6 +1008,14 @@ func (e *Engineer) ListReadyMRs() ([]*MRInfo, error) {
 			continue
 		}
 
+		// Belt-and-suspenders: skip MRs labeled gt:owned-direct.
+		// These MRs shouldn't exist (gt done skips MR creation for owned+direct
+		// convoys), but if one slips through, the refinery should not process it.
+		if beads.HasLabel(issue, "gt:owned-direct") {
+			_, _ = fmt.Fprintf(e.output, "[Engineer] Skipping MR %s: owned+direct convoy (belt-and-suspenders)\n", issue.ID)
+			continue
+		}
+
 		fields := beads.ParseMRFields(issue)
 		if fields == nil {
 			continue // Skip issues without MR fields