From 42fa637325051c424b1c2ff24d3924b391060415 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 11 Mar 2026 13:49:00 -0400
Subject: [PATCH 1/3] fix(penpal): prevent agent restart loop and UI vibration
 on comment

When the agent process starts but crashes quickly, the frontend's
auto-start logic would immediately restart it, creating a rapid loop
that toggled the agent indicator and working dots on/off causing the
UI to visibly vibrate.

Server: track "quick exits" (agent ran <15s) and block restarts for
30s after a quick exit. Return cooldown status in the agent API.

Frontend: respect server cooldown flag and add a 30s client-side rate
limit on auto-start attempts. Always render agent indicator and
working dots in the DOM using visibility:hidden when inactive so
toggling never causes layout shifts.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../frontend/src/components/CommentsPanel.tsx | 60 +++++++++---------
 apps/penpal/frontend/src/index.css            |  2 +
 apps/penpal/frontend/src/pages/FilePage.tsx   |  8 ++-
 apps/penpal/frontend/src/types.ts             |  1 +
 apps/penpal/internal/agents/manager.go        | 63 +++++++++++++++----
 5 files changed, 88 insertions(+), 46 deletions(-)

diff --git a/apps/penpal/frontend/src/components/CommentsPanel.tsx b/apps/penpal/frontend/src/components/CommentsPanel.tsx
index 4ab90328..5573a7f6 100644
--- a/apps/penpal/frontend/src/components/CommentsPanel.tsx
+++ b/apps/penpal/frontend/src/components/CommentsPanel.tsx
@@ -98,28 +98,26 @@ export default function CommentsPanel({
         <span>
           Comments {openCount > 0 && <span id="comments-count">{openCount}</span>}
         </span>
-        {agentStatus?.running && (
-          <span className="agent-indicator">
-            <span className="agent-dot" />
-            <span>Agent</span>
-            {agentStatus.contextPercent !== undefined && (
-              <span
-                className={`agent-context-label ${agentContextColorClass(agentStatus.contextPercent)}`}
-              >
-                {Math.round(agentStatus.contextPercent)}%
-              </span>
-            )}
-            <button
-              className="agent-stop-btn"
-              onClick={(e) => {
-                e.stopPropagation();
-                api.stopAgent(project).then(onRefresh);
-              }}
+        <span className={`agent-indicator${agentStatus?.running ? '' : ' hidden'}`}>
+          <span className="agent-dot" />
+          <span>Agent</span>
+          {agentStatus?.running && agentStatus.contextPercent !== undefined && (
+            <span
+              className={`agent-context-label ${agentContextColorClass(agentStatus.contextPercent)}`}
             >
-              Stop
-            </button>
-          </span>
-        )}
+              {Math.round(agentStatus.contextPercent)}%
+            </span>
+          )}
+          <button
+            className="agent-stop-btn"
+            onClick={(e) => {
+              e.stopPropagation();
+              api.stopAgent(project).then(onRefresh);
+            }}
+          >
+            Stop
+          </button>
+        </span>
         {resolvedThreads.length > 0 && (
           <span id="resolved-toggle">
             <label style={{ cursor: 'pointer', fontWeight: 'normal', textTransform: 'none', letterSpacing: 'normal' }}>
@@ -456,17 +454,15 @@ function ThreadCard({
         </div>
       )}
 
-      {/* Working indicator */}
-      {thread.agentWorking && (
-        <div className="thread-working">
-          <span className="agent-dot" />
-          <span className="working-dots">
-            <span>.</span>
-            <span>.</span>
-            <span>.</span>
-          </span>
-        </div>
-      )}
+      {/* Working indicator — always rendered to avoid layout shift */}
+      <div className={`thread-working${thread.agentWorking ? '' : ' hidden'}`}>
+        <span className="agent-dot" />
+        <span className="working-dots">
+          <span>.</span>
+          <span>.</span>
+          <span>.</span>
+        </span>
+      </div>
 
       {/* Actions */}
       {!replyOpen && (
diff --git a/apps/penpal/frontend/src/index.css b/apps/penpal/frontend/src/index.css
index e58f5c7a..b8a19d12 100644
--- a/apps/penpal/frontend/src/index.css
+++ b/apps/penpal/frontend/src/index.css
@@ -953,6 +953,7 @@ a:hover { text-decoration: underline; }
   margin-left: auto;
   margin-right: 8px;
 }
+.agent-indicator.hidden { visibility: hidden; }
 .agent-indicator .agent-dot {
   display: inline-block;
   width: 7px;
@@ -985,6 +986,7 @@ a:hover { text-decoration: underline; }
   color: var(--accent-success);
   font-size: 0.85em;
 }
+.thread-working.hidden { visibility: hidden; }
 .thread-working .agent-dot {
   display: inline-block;
   width: 7px;
diff --git a/apps/penpal/frontend/src/pages/FilePage.tsx b/apps/penpal/frontend/src/pages/FilePage.tsx
index 4b80cc06..3c093317 100644
--- a/apps/penpal/frontend/src/pages/FilePage.tsx
+++ b/apps/penpal/frontend/src/pages/FilePage.tsx
@@ -35,6 +35,7 @@ export default function FilePage() {
   const contentRef = useRef<HTMLDivElement>(null);
   const mermaidDraggingRef = useRef(false);
   const agentPollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const lastAutoStartRef = useRef<number>(0);
   const [chatWidth, setChatWidth] = useState(() => {
     const saved = localStorage.getItem('chatPanelWidth');
     return saved ? parseInt(saved, 10) : 340;
@@ -204,7 +205,12 @@ export default function FilePage() {
     try {
       const status = await api.getAgentStatus(project);
       setAgentStatus(status);
-      if (status.needsAgent && !status.running) {
+      if (status.needsAgent && !status.running && !status.cooldown) {
+        // Rate limit: don't auto-start if we attempted one recently.
+        // This prevents rapid restart loops when the agent keeps crashing.
+        const now = Date.now();
+        if (now - lastAutoStartRef.current < 30_000) return;
+        lastAutoStartRef.current = now;
         // Auto-start, then fetch updated status to show the running dot
         try {
           await api.startAgent(project);
diff --git a/apps/penpal/frontend/src/types.ts b/apps/penpal/frontend/src/types.ts
index c30785eb..2ff34f91 100644
--- a/apps/penpal/frontend/src/types.ts
+++ b/apps/penpal/frontend/src/types.ts
@@ -155,6 +155,7 @@ export interface AgentStatus {
   pid: number;
   startedAt: string;
   running: boolean;
+  cooldown?: boolean;
   contextWindow: number;
   contextUsed: number;
   contextPercent: number;
diff --git a/apps/penpal/internal/agents/manager.go b/apps/penpal/internal/agents/manager.go
index dd3b0a3e..ff00f773 100644
--- a/apps/penpal/internal/agents/manager.go
+++ b/apps/penpal/internal/agents/manager.go
@@ -30,23 +30,34 @@ type Agent struct {
 	numTurns      int     // number of assistant turns
 }
 
+// quickExitThreshold is the minimum run time to consider an agent exit
+// "normal". Exits faster than this are tracked as quick exits to prevent
+// rapid restart loops.
+const quickExitThreshold = 15 * time.Second
+
+// restartCooldown is the minimum time to wait after a quick exit before
+// allowing another agent start for the same project.
+const restartCooldown = 30 * time.Second
+
 // Manager manages Claude Code agent processes, one per project.
 type Manager struct {
-	mu        sync.Mutex
-	agents    map[string]*Agent // key: qualified project name
-	cache     *cache.Cache
-	comments  *comments.Store
-	port      int
-	onChange  func(projectName string) // called when agent starts or stops
-	claudeBin func() string            // returns resolved path to claude binary
+	mu            sync.Mutex
+	agents        map[string]*Agent     // key: qualified project name
+	lastQuickExit map[string]time.Time  // key: project name -> time of last quick exit
+	cache         *cache.Cache
+	comments      *comments.Store
+	port          int
+	onChange      func(projectName string) // called when agent starts or stops
+	claudeBin     func() string            // returns resolved path to claude binary
 }
 
 func New(c *cache.Cache, cs *comments.Store, port int) *Manager {
 	return &Manager{
-		agents:   make(map[string]*Agent),
-		cache:    c,
-		comments: cs,
-		port:     port,
+		agents:        make(map[string]*Agent),
+		lastQuickExit: make(map[string]time.Time),
+		cache:         c,
+		comments:      cs,
+		port:          port,
 	}
 }
 
@@ -65,7 +76,8 @@ func (m *Manager) SetOnChange(fn func(projectName string)) {
 }
 
 // Start launches a Claude agent for the given project.
-// Returns nil if an agent is already running for this project.
+// Returns nil if an agent is already running for this project or if the
+// project is in a restart cooldown (last agent exited quickly).
 func (m *Manager) Start(projectName string) (*Agent, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -80,6 +92,13 @@ func (m *Manager) Start(projectName string) (*Agent, error) {
 		}
 	}
 
+	// Prevent rapid restart loops: if the last agent for this project
+	// exited quickly (crashed), wait before allowing another start.
+	if t, ok := m.lastQuickExit[projectName]; ok && time.Since(t) < restartCooldown {
+		log.Printf("Agent start for %s blocked: cooldown after quick exit (%s ago)", projectName, time.Since(t).Round(time.Second))
+		return nil, nil
+	}
+
 	proj := m.cache.FindProject(projectName)
 	if proj == nil {
 		return nil, fmt.Errorf("project %q not found", projectName)
@@ -161,7 +180,17 @@ func (m *Manager) Start(projectName string) (*Agent, error) {
 		logFile.Close()
 		os.Remove(mcpConfigPath)
 		close(agent.done)
-		log.Printf("Agent exited for %s (PID %d): %v", projectName, agent.PID, agent.exitErr)
+
+		runDuration := time.Since(agent.StartedAt)
+		log.Printf("Agent exited for %s (PID %d, ran %s): %v", projectName, agent.PID, runDuration.Round(time.Second), agent.exitErr)
+
+		// Track quick exits to prevent rapid restart loops
+		if runDuration < quickExitThreshold {
+			m.mu.Lock()
+			m.lastQuickExit[projectName] = time.Now()
+			m.mu.Unlock()
+			log.Printf("Agent for %s exited quickly (%s) — restart cooldown active for %s", projectName, runDuration.Round(time.Millisecond), restartCooldown)
+		}
 
 		m.comments.ClearProjectHeartbeats(projectName)
 		m.comments.ClearProjectWorking(projectName)
@@ -219,6 +248,7 @@ type AgentStatus struct {
 	PID            int       `json:"pid"`
 	StartedAt      time.Time `json:"startedAt"`
 	Running        bool      `json:"running"`
+	Cooldown       bool      `json:"cooldown,omitempty"` // true when agent recently crashed and restarts are blocked
 	ContextWindow  int       `json:"contextWindow"`
 	ContextUsed    int       `json:"contextUsed"`
 	ContextPercent float64   `json:"contextPercent"`
@@ -233,6 +263,13 @@ func (m *Manager) Status(projectName string) *AgentStatus {
 
 	agent, ok := m.agents[projectName]
 	if !ok {
+		// No agent exists — check if we're in cooldown
+		if t, ok := m.lastQuickExit[projectName]; ok && time.Since(t) < restartCooldown {
+			return &AgentStatus{
+				Project:  projectName,
+				Cooldown: true,
+			}
+		}
 		return nil
 	}
 

From 1c3cc8018484f73e92146021e7abdafe4199cf7a Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 11 Mar 2026 14:55:35 -0400
Subject: [PATCH 2/3] test(penpal): add tests for agent restart cooldown and
 layout stability

Go tests (manager_test.go):
- Start blocked during cooldown
- Start allowed after cooldown expires
- Cooldown scoped per-project
- Status returns cooldown flag when active
- Status returns nil after cooldown expires
- Cooldown not reported when agent is running

Server API tests (api_agents_test.go):
- GET /api/agents returns cooldown=true after quick exit
- POST /api/agents/start blocked during cooldown

Frontend tests:
- FilePage: cooldown blocks auto-start
- FilePage: rate-limits prevent rapid restart loops
- CommentsPanel: agent indicator always in DOM (hidden class)
- CommentsPanel: working dots always in DOM (hidden class)
- CommentsPanel: indicator toggles hidden class on rerender

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../src/components/CommentsPanel.test.tsx     |  52 +++++-
 .../frontend/src/pages/FilePage.test.tsx      |  39 +++++
 apps/penpal/internal/agents/manager.go        |   9 +
 apps/penpal/internal/agents/manager_test.go   | 156 ++++++++++++++++++
 .../penpal/internal/server/api_agents_test.go |  68 ++++++++
 5 files changed, 322 insertions(+), 2 deletions(-)
 create mode 100644 apps/penpal/internal/agents/manager_test.go

diff --git a/apps/penpal/frontend/src/components/CommentsPanel.test.tsx b/apps/penpal/frontend/src/components/CommentsPanel.test.tsx
index 60822e22..e05df6fb 100644
--- a/apps/penpal/frontend/src/components/CommentsPanel.test.tsx
+++ b/apps/penpal/frontend/src/components/CommentsPanel.test.tsx
@@ -134,10 +134,26 @@ describe('CommentsPanel', () => {
     expect(screen.getByText('Anchor text not found in document')).toBeDefined();
   });
 
-  it('renders agent working indicator', () => {
+  it('renders agent working indicator visible when active', () => {
     const workingThread: ThreadResponse = { ...mockThread, agentWorking: true };
     const { container } = renderPanel([workingThread]);
-    expect(container.querySelector('.thread-working')).toBeDefined();
+    const el = container.querySelector('.thread-working');
+    expect(el).toBeDefined();
+    expect(el?.classList.contains('hidden')).toBe(false);
+  });
+
+  it('renders agent working indicator hidden when inactive', () => {
+    const { container } = renderPanel([mockThread]);
+    const el = container.querySelector('.thread-working');
+    expect(el).toBeDefined();
+    expect(el?.classList.contains('hidden')).toBe(true);
+  });
+
+  it('always renders agent indicator in DOM for layout stability', () => {
+    const { container } = renderPanel();
+    const el = container.querySelector('.agent-indicator');
+    expect(el).toBeDefined();
+    expect(el?.classList.contains('hidden')).toBe(true);
   });
 
   it('renders agent status indicator when running', () => {
@@ -156,4 +172,36 @@ describe('CommentsPanel', () => {
     expect(screen.getByText('Agent')).toBeDefined();
     expect(screen.getByText('45%')).toBeDefined();
   });
+
+  it('agent indicator is visible when running, hidden when not', () => {
+    const { container, rerender } = render(
+      <MemoryRouter>
+        <CommentsPanel
+          threads={[mockThread]}
+          anchorLines={{ 'thread-1': 5 }}
+          project="test/project"
+          filePath="thoughts/test.md"
+          onRefresh={vi.fn()}
+          agentStatus={{ running: true, contextPercent: 45 }}
+        />
+      </MemoryRouter>,
+    );
+    const indicator = container.querySelector('.agent-indicator');
+    expect(indicator?.classList.contains('hidden')).toBe(false);
+
+    rerender(
+      <MemoryRouter>
+        <CommentsPanel
+          threads={[mockThread]}
+          anchorLines={{ 'thread-1': 5 }}
+          project="test/project"
+          filePath="thoughts/test.md"
+          onRefresh={vi.fn()}
+          agentStatus={{ running: false }}
+        />
+      </MemoryRouter>,
+    );
+    const indicatorAfter = container.querySelector('.agent-indicator');
+    expect(indicatorAfter?.classList.contains('hidden')).toBe(true);
+  });
 });
diff --git a/apps/penpal/frontend/src/pages/FilePage.test.tsx b/apps/penpal/frontend/src/pages/FilePage.test.tsx
index ac3afd27..d1461457 100644
--- a/apps/penpal/frontend/src/pages/FilePage.test.tsx
+++ b/apps/penpal/frontend/src/pages/FilePage.test.tsx
@@ -433,6 +433,45 @@ describe('FilePage', () => {
     });
   });
 
+  it('does not auto-start agent when server reports cooldown', async () => {
+    vi.mocked(api.getAgentStatus).mockResolvedValue({
+      ...agentNotRunning,
+      needsAgent: true,
+      cooldown: true,
+    });
+
+    renderFilePage();
+
+    await waitFor(() => {
+      expect(api.getAgentStatus).toHaveBeenCalled();
+    });
+
+    expect(api.startAgent).not.toHaveBeenCalled();
+  });
+
+  it('rate-limits auto-start attempts to prevent rapid restart loops', async () => {
+    // First call: needsAgent triggers auto-start
+    vi.mocked(api.getAgentStatus)
+      .mockResolvedValueOnce({ ...agentNotRunning, needsAgent: true })
+      .mockResolvedValue({ ...agentNotRunning, needsAgent: true });
+    vi.mocked(api.startAgent).mockResolvedValue(agentNotRunning);
+
+    renderFilePage();
+
+    await waitFor(() => {
+      expect(api.startAgent).toHaveBeenCalledTimes(1);
+    });
+
+    // Simulate SSE agent event triggering another fetchAgentStatus
+    const { onEvent } = getSSECallbacks();
+    await act(async () => {
+      onEvent!({ type: 'agents', project: 'ws/proj' });
+    });
+
+    // Should NOT have auto-started again (rate limited to 30s)
+    expect(api.startAgent).toHaveBeenCalledTimes(1);
+  });
+
   it('refreshes content on SSE files event', async () => {
     vi.mocked(api.getAgentStatus).mockResolvedValue(agentNotRunning);
 
diff --git a/apps/penpal/internal/agents/manager.go b/apps/penpal/internal/agents/manager.go
index ff00f773..72c46d1c 100644
--- a/apps/penpal/internal/agents/manager.go
+++ b/apps/penpal/internal/agents/manager.go
@@ -321,6 +321,15 @@ func (m *Manager) SimulateFinished(projectName string) {
 	}
 }
 
+// SetQuickExit records a quick exit for the given project, activating the
+// restart cooldown. This is intended for testing the cooldown behavior
+// without requiring an actual agent process.
+func (m *Manager) SetQuickExit(projectName string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.lastQuickExit[projectName] = time.Now()
+}
+
 // StopAll terminates all running agents (for server shutdown).
 func (m *Manager) StopAll() {
 	m.mu.Lock()
diff --git a/apps/penpal/internal/agents/manager_test.go b/apps/penpal/internal/agents/manager_test.go
new file mode 100644
index 00000000..40a01c41
--- /dev/null
+++ b/apps/penpal/internal/agents/manager_test.go
@@ -0,0 +1,156 @@
+package agents
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/loganj/penpal/internal/cache"
+)
+
+func TestStart_BlockedDuringCooldown(t *testing.T) {
+	m := &Manager{
+		agents:        make(map[string]*Agent),
+		lastQuickExit: map[string]time.Time{"proj": time.Now()},
+		cache:         cache.New(),
+	}
+
+	agent, err := m.Start("proj")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if agent != nil {
+		t.Error("expected nil agent during cooldown, got non-nil")
+	}
+}
+
+func TestStart_AllowedAfterCooldownExpires(t *testing.T) {
+	m := &Manager{
+		agents:        make(map[string]*Agent),
+		lastQuickExit: map[string]time.Time{"proj": time.Now().Add(-restartCooldown - time.Second)},
+		cache:         cache.New(),
+	}
+
+	// Start will fail because there's no real project in cache, but it should
+	// get past the cooldown check and fail on the project lookup instead.
+	_, err := m.Start("proj")
+	if err == nil {
+		t.Fatal("expected error from missing project, got nil")
+	}
+	// The error should be about the project not being found, not about cooldown
+	if err.Error() != `project "proj" not found` {
+		t.Errorf("unexpected error: %v", err)
+	}
+}
+
+func TestStart_CooldownDoesNotAffectOtherProjects(t *testing.T) {
+	m := &Manager{
+		agents:        make(map[string]*Agent),
+		lastQuickExit: map[string]time.Time{"proj-a": time.Now()},
+		cache:         cache.New(),
+	}
+
+	// proj-b should not be blocked by proj-a's cooldown
+	_, err := m.Start("proj-b")
+	if err == nil {
+		t.Fatal("expected error from missing project, got nil")
+	}
+	if err.Error() != `project "proj-b" not found` {
+		t.Errorf("expected project-not-found error, got: %v", err)
+	}
+}
+
+func TestStatus_ReturnsCooldownWhenNoAgent(t *testing.T) {
+	m := &Manager{
+		agents:        make(map[string]*Agent),
+		lastQuickExit: map[string]time.Time{"proj": time.Now()},
+	}
+
+	status := m.Status("proj")
+	if status == nil {
+		t.Fatal("expected non-nil status during cooldown")
+	}
+	if !status.Cooldown {
+		t.Error("expected Cooldown=true")
+	}
+	if status.Running {
+		t.Error("expected Running=false during cooldown")
+	}
+	if status.Project != "proj" {
+		t.Errorf("expected Project=proj, got %s", status.Project)
+	}
+}
+
+func TestStatus_NoCooldownWhenExpired(t *testing.T) {
+	m := &Manager{
+		agents:        make(map[string]*Agent),
+		lastQuickExit: map[string]time.Time{"proj": time.Now().Add(-restartCooldown - time.Second)},
+	}
+
+	status := m.Status("proj")
+	if status != nil {
+		t.Errorf("expected nil status after cooldown expires, got %+v", status)
+	}
+}
+
+func TestStatus_NoCooldownWhenAgentRunning(t *testing.T) {
+	a := newTestAgent()
+	a.Project = "proj"
+	a.done = make(chan struct{}) // open = running
+
+	m := &Manager{
+		agents:        map[string]*Agent{"proj": a},
+		lastQuickExit: map[string]time.Time{"proj": time.Now()}, // cooldown active but agent is running
+	}
+
+	status := m.Status("proj")
+	if status == nil {
+		t.Fatal("expected non-nil status for running agent")
+	}
+	if status.Cooldown {
+		t.Error("expected Cooldown=false when agent is running")
+	}
+	if !status.Running {
+		t.Error("expected Running=true")
+	}
+}
+
+func TestStatus_NilForUnknownProjectNoCooldown(t *testing.T) {
+	m := &Manager{
+		agents:        make(map[string]*Agent),
+		lastQuickExit: make(map[string]time.Time),
+	}
+
+	status := m.Status("unknown")
+	if status != nil {
+		t.Errorf("expected nil status for unknown project, got %+v", status)
+	}
+}
+
+func TestQuickExitThresholdAndCooldownConstants(t *testing.T) {
+	// Sanity check: cooldown should be longer than the threshold
+	if restartCooldown <= quickExitThreshold {
+		t.Errorf("restartCooldown (%s) should be > quickExitThreshold (%s)", restartCooldown, quickExitThreshold)
+	}
+}
+
+func TestStart_ReturnsNilForAlreadyRunningAgent(t *testing.T) {
+	a := &Agent{
+		Project: "proj",
+		done:    make(chan struct{}), // open = running
+	}
+
+	m := &Manager{
+		mu:            sync.Mutex{},
+		agents:        map[string]*Agent{"proj": a},
+		lastQuickExit: make(map[string]time.Time),
+	}
+
+	agent, err := m.Start("proj")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if agent != nil {
+		t.Error("expected nil agent for already-running project")
+	}
+}
diff --git a/apps/penpal/internal/server/api_agents_test.go b/apps/penpal/internal/server/api_agents_test.go
index 7d5c622a..5eb216c9 100644
--- a/apps/penpal/internal/server/api_agents_test.go
+++ b/apps/penpal/internal/server/api_agents_test.go
@@ -115,6 +115,74 @@ func TestAPIAgentStatus_NoNeedsAgent_WhenAgentReplied(t *testing.T) {
 	}
 }
 
+func TestAPIAgentStatus_CooldownAfterQuickExit(t *testing.T) {
+	s, c, cs := testServer(t)
+	s.agents = agents.New(c, cs, 0)
+	dir := t.TempDir()
+	seedProject(c, "test-proj", dir, nil)
+
+	// Simulate a quick exit by directly setting the cooldown state
+	s.agents.SetQuickExit("test-proj")
+
+	// Create a pending human comment
+	anchor := comments.Anchor{SelectedText: "review me"}
+	comment := comments.Comment{Author: "user", Role: "human", Body: "New comment"}
+	_, err := cs.CreateThread("test-proj", "thoughts/plan.md", anchor, comment)
+	if err != nil {
+		t.Fatalf("create thread: %v", err)
+	}
+
+	req := httptest.NewRequest(http.MethodGet, "/api/agents?project=test-proj", nil)
+	rec := httptest.NewRecorder()
+	s.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rec.Code)
+	}
+
+	var resp map[string]interface{}
+	json.Unmarshal(rec.Body.Bytes(), &resp)
+
+	if resp["running"] != false {
+		t.Errorf("expected running=false during cooldown")
+	}
+	if resp["cooldown"] != true {
+		t.Errorf("expected cooldown=true, got %v", resp["cooldown"])
+	}
+	// needsAgent should still be true (there ARE pending comments)
+	if resp["needsAgent"] != true {
+		t.Errorf("expected needsAgent=true during cooldown with pending comments, got %v", resp["needsAgent"])
+	}
+}
+
+func TestAPIAgentStatus_StartBlockedDuringCooldown(t *testing.T) {
+	s, c, cs := testServer(t)
+	s.agents = agents.New(c, cs, 0)
+	dir := t.TempDir()
+	seedProject(c, "test-proj", dir, nil)
+
+	s.agents.SetQuickExit("test-proj")
+
+	// Attempting to start should succeed (HTTP 200) but not actually launch
+	req := httptest.NewRequest(http.MethodPost, "/api/agents/start?project=test-proj", nil)
+	rec := httptest.NewRecorder()
+	s.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", rec.Code, rec.Body.String())
+	}
+
+	var resp map[string]interface{}
+	json.Unmarshal(rec.Body.Bytes(), &resp)
+
+	if resp["running"] != false {
+		t.Errorf("expected running=false (start blocked by cooldown)")
+	}
+	if resp["cooldown"] != true {
+		t.Errorf("expected cooldown=true in start response")
+	}
+}
+
 func TestAPIAgentStatus_NeedsAgent_AfterAgentFinished(t *testing.T) {
 	s, c, cs := testServer(t)
 	s.agents = agents.New(c, cs, 0)

From c219a2a1367b799e22c8b3bc1b00fef5a4437a04 Mon Sep 17 00:00:00 2001
From: Logan Johnson <loganj@squareup.com>
Date: Wed, 11 Mar 2026 15:25:23 -0400
Subject: [PATCH 3/3] fix: gofmt formatting in Manager struct field comments

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
---
 apps/penpal/internal/agents/manager.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/penpal/internal/agents/manager.go b/apps/penpal/internal/agents/manager.go
index 72c46d1c..faf1c586 100644
--- a/apps/penpal/internal/agents/manager.go
+++ b/apps/penpal/internal/agents/manager.go
@@ -42,8 +42,8 @@ const restartCooldown = 30 * time.Second
 // Manager manages Claude Code agent processes, one per project.
 type Manager struct {
 	mu            sync.Mutex
-	agents        map[string]*Agent     // key: qualified project name
-	lastQuickExit map[string]time.Time  // key: project name -> time of last quick exit
+	agents        map[string]*Agent    // key: qualified project name
+	lastQuickExit map[string]time.Time // key: project name -> time of last quick exit
 	cache         *cache.Cache
 	comments      *comments.Store
 	port          int