merge: unify chat sin_edit with MCP (#373) + build fixes for all 6 merges

Author: SIN CI

cmd/sin-code/internal/agentloop/loop.go

@@ -235,10 +235,12 @@ type Loop struct {
 	CoverageForbiddenTools []string
 
 	// ResultPolicy, if set, scans every tool result for secret leakage,
-	// destructive operations, and network egress. It can block subsequent
-	// writes or require confirmation for the next destructive tool call
-	// (issue #374). Optional — nil preserves legacy behavior.
-	ResultPolicy *permission.ResultPolicyStore
+	// destructive operations, and network egress (issue #374).
+	ResultPolicy *permission.ResultPolicy
+
+	// Observer, when set, observes tool calls via Observe/LastTrip
+	// for full fingerprint-based loop detection (issue #377).
+	Observer *LoopDetector
 
 	// RunOverride, if set, replaces the default Run. Used by the
 	// WebUI v2 chat API (issue #52) so tests can swap in a
@@ -252,12 +254,6 @@ type Loop struct {
 	// == "poc" (issue #290).
 	TournamentRunner TournamentRunner
 
-	// ResultPolicy, if set, scans the string returned by every executed
-	// tool and surfaces warnings/escalations for secret leakage,
-	// destructive confirmations, or network egress markers (issue #374).
-	// Optional — nil preserves exact legacy behavior.
-	ResultPolicy *permission.ResultPolicy
-
 	// Frustration, when set, tracks user message patterns for frustration
 	// signals and appends a system-prompt suffix when detected (issue #271).
 	// Optional — nil preserves legacy behavior.
@@ -1235,9 +1231,9 @@ func (l *Loop) Run(ctx context.Context, sess *session.Session, prompt string) (*
 			// TOOL REFUSED message and skip execute() so the model
 			// gets feedback AND the dispatch site never reaches a
 			// destructive mutator while the worker is thrashing.
-			if l.Observer != nil && l.Observer.Enabled() {
-				if oerr := l.Observer.Observe(tc, ""); oerr != nil {
-					trip := l.Observer.LastTrip()
+			if l.LoopDetector != nil && l.LoopDetector.Enabled() {
+				if oerr := l.LoopDetector.Observe(tc, ""); oerr != nil {
+					trip := l.LoopDetector.LastTrip()
 					data := map[string]any{"reason": "loop.detected"}
 					if trip != nil {
 						data["pattern_length"] = trip.Length

cmd/sin-code/internal/agentloop/loop_detector.go

@@ -16,8 +16,12 @@ func NewSimpleLoopDetector(maxRepeats, windowSize int) *LoopDetector {
 	if windowSize < 1 {
 		windowSize = 1
 	}
+	w := maxRepeats * windowSize
+	if w < maxRepeats {
+		w = maxRepeats
+	}
 	return &LoopDetector{
-		Window:           windowSize,
+		Window:           w,
 		MinPatternLength: 1,
 		MinRepeats:       maxRepeats,
 	}

cmd/sin-code/internal/agentloop/loop_detector_test.go

@@ -9,8 +9,8 @@ import (
 
 func TestNewLoopDetector_Defaults(t *testing.T) {
 	d := NewSimpleLoopDetector(0, 0)
-	if d.maxRepeats != 1 || d.windowSize != 1 {
-		t.Fatalf("clamped values = (%d,%d), want (1,1)", d.maxRepeats, d.windowSize)
+	if d.MinRepeats != 1 || d.Window != 1 {
+		t.Fatalf("clamped values = (%d,%d), want (1,1)", d.MinRepeats, d.Window)
 	}
 	if d.IsLooping() {
 		t.Fatal("empty detector should not loop")

cmd/sin-code/internal/agentloop/loop_observer.go

@@ -168,40 +168,44 @@ func (d *LoopDetector) Observe(tc ToolCall, messageHash string) error {
 	return d.evaluateLocked()
 }
 
-// evaluateLocked re-scans the history for the longest qualifying
-// repetition and trips the detector on the first match. Caller holds
-// d.mu.
+// evaluateLocked re-scans the history for qualifying repetitions and
+// trips the detector on the first match. It checks all pattern lengths
+// from longest to shortest so that a longer partial-repeat does not
+// mask a shorter full-repeat. Caller holds d.mu.
 func (d *LoopDetector) evaluateLocked() error {
 	n := len(d.history)
 	if n < d.MinPatternLength*d.MinRepeats {
 		return nil
 	}
-	p := longestMatchingPrefix(d.history)
-	if p < d.MinPatternLength {
-		return nil
-	}
-	repeats := n / p
-	if repeats < d.MinRepeats {
-		return nil
-	}
-	pattern := make([]string, p)
-	for i := 0; i < p; i++ {
-		pattern[i] = d.history[n-p+i].Key
-	}
-	d.tripped = true
-	d.pattern = pattern
-	name := d.history[n-1].Name
-	if name == "" {
-		name = "unknown"
-	}
-	d.trip = &LoopTrip{
-		ToolName:   name,
-		Length:     p,
-		Repeats:    repeats,
-		Key:        d.history[n-1].Key,
-		HistoryLen: n,
+	upper := n / 2
+	for p := upper; p >= d.MinPatternLength; p-- {
+		if !equalAt(d.history, n-p, n-2*p, p) {
+			continue
+		}
+		repeats := n / p
+		if repeats < d.MinRepeats {
+			continue
+		}
+		pattern := make([]string, p)
+		for i := 0; i < p; i++ {
+			pattern[i] = d.history[n-p+i].Key
+		}
+		d.tripped = true
+		d.pattern = pattern
+		name := d.history[n-1].Name
+		if name == "" {
+			name = "unknown"
+		}
+		d.trip = &LoopTrip{
+			ToolName:   name,
+			Length:     p,
+			Repeats:    repeats,
+			Key:        d.history[n-1].Key,
+			HistoryLen: n,
+		}
+		return ErrLoopDetected
 	}
-	return ErrLoopDetected
+	return nil
 }
 
 // Reset clears the detector state so a new run / session starts

cmd/sin-code/internal/agentloop/per_turn_budget_test.go

@@ -9,11 +9,11 @@ import (
 
 func TestNewPerTurnBudget_Defaults(t *testing.T) {
 	b := NewPerTurnBudget(1000, 2000)
-	if b.ThinkingTokens != 1000 {
-		t.Fatalf("ThinkingTokens = %d, want 1000", b.ThinkingTokens)
+	if b.ThinkingRemaining() != 1000 {
+		t.Fatalf("ThinkingRemaining = %d, want 1000", b.ThinkingRemaining())
 	}
-	if b.TokenTokens != 2000 {
-		t.Fatalf("TokenTokens = %d, want 2000", b.TokenTokens)
+	if b.TokensRemaining() != 2000 {
+		t.Fatalf("TokensRemaining = %d, want 2000", b.TokensRemaining())
 	}
 	th, tk := b.Stats()
 	if th != 0 || tk != 0 {

cmd/sin-code/internal/agentloop/session_context_loop_test.go

@@ -13,6 +13,24 @@ import (
 	"github.com/OpenSIN-Code/SIN-Code/cmd/sin-code/internal/verify"
 )
 
+type mockTodoReader struct {
+	items []string
+}
+
+func (m *mockTodoReader) Open(blockedOnly bool) ([]string, error) { return m.items, nil }
+
+type mockSessionSummaryReader struct {
+	summary string
+}
+
+func (m *mockSessionSummaryReader) Summary(sessionID string) (string, error) { return m.summary, nil }
+
+type mockAutoMemoryReader struct {
+	data []byte
+}
+
+func (m *mockAutoMemoryReader) IndexBytes() ([]byte, error) { return m.data, nil }
+
 func TestSessionContextPrependedOnNewSession(t *testing.T) {
 	var first []session.Message
 	captured := false