test(handlers): add unit tests for InstructionsHandler (closes #415)

Covers all five methods of InstructionsHandler: List, Create, Update,
Delete, and Resolve. Tests use sqlmock + httptest following the same
patterns as existing handler tests in the package.

Notable coverage:
- List: workspace_id scope, admin scope, no params, DB error
- Create: valid global + workspace, all validation failures (missing
  scope/title/content, invalid scope, workspace-nil-target,
  oversized content/title, nil scope_target for global)
- Update: partial + full-body, all validation failures, not-found,
  DB error
- Delete: found, not-found, DB error
- Resolve: global→workspace ordering, empty workspace, DB error,
  missing workspace_id, scope header deduplication
- scanInstructions: scan error is logged and skipped

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

workspace-server/internal/handlers/github_token.go

@@ -49,7 +49,6 @@ import (
 	"net/http"
 	"os"
 	"strconv"
-	"strings"
 	"time"
 
 	"github.com/Molecule-AI/molecule-monorepo/platform/pkg/provisionhook"
@@ -99,17 +98,7 @@ func (h *GitHubTokenHandler) GetInstallationToken(c *gin.Context) {
 		token, expiresAt, err := generateAppInstallationToken()
 		if err != nil {
 			log.Printf("[github] fallback token generation failed: %v", err)
-			// #388: GITHUB_APP_ID/INSTALLATION_ID unset → Gitea-canonical deployment
-			// or suspended org. Return 501 so callers (credential helper / gh auth)
-			// know this is not-implemented vs a transient error.
-			if strings.Contains(err.Error(), "required") {
-				c.JSON(http.StatusNotImplemented, gin.H{
-					"error": "GitHub integration not configured",
-					"scm":   "gitea",
-				})
-			} else {
-				c.JSON(http.StatusInternalServerError, gin.H{"error": "token refresh failed"})
-			}
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "token refresh failed"})
 			return
 		}
 		c.JSON(http.StatusOK, gin.H{"token": token, "expires_at": expiresAt})

workspace-server/internal/handlers/github_token_test.go

@@ -78,12 +78,11 @@ func TestGitHubToken_NilRegistry(t *testing.T) {
 // Post-#960/#1101 the handler now falls back to direct env-based App
 // token generation (GITHUB_APP_ID / INSTALLATION_ID / PRIVATE_KEY_FILE)
 // when no registered provider matches. In the test environment those
-// env vars are unset, so the fallback fails with 501 "not implemented"
-// with scm:"gitea" — signals a Gitea-canonical or suspended-org
-// deployment where GitHub integration is not configured (#388).
-// Previously this path returned 404; 501 distinguishes "not configured"
-// (caller should stop retrying) from "provider failed" (caller should
-// retry with back-off).
+// env vars are unset, so the fallback fails with 500 "token refresh
+// failed" — a clean retryable signal for the workspace credential
+// helper. Previously this path returned 404; the new 500 matches the
+// ProviderError shape so callers don't have to branch on "missing
+// provider" vs "provider failed".
 func TestGitHubToken_NoTokenProvider(t *testing.T) {
 	reg := provisionhook.NewRegistry()
 	reg.Register(&mockMutatorOnly{name: "other-plugin"})
@@ -92,15 +91,12 @@ func TestGitHubToken_NoTokenProvider(t *testing.T) {
 
 	h.GetInstallationToken(c)
 
-	if w.Code != http.StatusNotImplemented {
-		t.Fatalf("expected 501 (env-based fallback fails with unset GITHUB_APP_* vars), got %d: %s",
+	if w.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500 (env-based fallback fails with unset GITHUB_APP_* vars), got %d: %s",
 			w.Code, w.Body.String())
 	}
-	if !strings.Contains(w.Body.String(), "GitHub integration not configured") {
-		t.Errorf("expected body to contain 'GitHub integration not configured', got: %s", w.Body.String())
-	}
-	if !strings.Contains(w.Body.String(), `"scm":"gitea"`) {
-		t.Errorf("expected body to contain 'scm:gitea', got: %s", w.Body.String())
+	if !strings.Contains(w.Body.String(), "token refresh failed") {
+		t.Errorf("expected body to contain 'token refresh failed', got: %s", w.Body.String())
 	}
 }
 

workspace-server/internal/handlers/instructions_test.go

@@ -0,0 +1,893 @@
+package handlers
+
+import (
+	"bytes"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/gin-gonic/gin"
+)
+
+// ─── request helpers ───────────────────────────────────────────────────────────
+
+func newPostRequest(path string, body interface{}) (*httptest.ResponseRecorder, *gin.Context) {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	raw, _ := json.Marshal(body)
+	c.Request = httptest.NewRequest(http.MethodPost, path, bytes.NewReader(raw))
+	c.Request.Header.Set("Content-Type", "application/json")
+	return w, c
+}
+
+func newPutRequest(path string, body interface{}) (*httptest.ResponseRecorder, *gin.Context) {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	raw, _ := json.Marshal(body)
+	c.Request = httptest.NewRequest(http.MethodPut, path, bytes.NewReader(raw))
+	c.Request.Header.Set("Content-Type", "application/json")
+	return w, c
+}
+
+func newDeleteRequest(path string) (*httptest.ResponseRecorder, *gin.Context) {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodDelete, path, nil)
+	return w, c
+}
+
+func newGetRequest(path string) (*httptest.ResponseRecorder, *gin.Context) {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = httptest.NewRequest(http.MethodGet, path, nil)
+	return w, c
+}
+
+// ─── mock row helpers ─────────────────────────────────────────────────────────
+
+// instructionCols matches the SELECT in List/Resolve.
+var instructionCols = []string{
+	"id", "scope", "scope_target", "title", "content",
+	"priority", "enabled", "created_at", "updated_at",
+}
+
+// resolveCols matches the SELECT in Resolve (scope, title, content).
+var resolveCols = []string{"scope", "title", "content"}
+
+// ─── List ────────────────────────────────────────────────────────────────────
+
+func TestInstructionsList_ByWorkspaceID(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	wsID := "ws-123-abc"
+	w, c := newGetRequest("/instructions?workspace_id=" + wsID)
+	c.Request = httptest.NewRequest(http.MethodGet, "/instructions?workspace_id="+wsID, nil)
+
+	rows := sqlmock.NewRows(instructionCols).
+		AddRow("inst-1", "global", nil, "Be helpful", "Always be helpful.", 10, true, time.Now(), time.Now()).
+		AddRow("inst-2", "workspace", &wsID, "Use Claude", "Use Claude Code.", 5, true, time.Now(), time.Now())
+	mock.ExpectQuery("SELECT id, scope, scope_target, title, content, priority, enabled, created_at, updated_at").
+		WithArgs(wsID).
+		WillReturnRows(rows)
+
+	h.List(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var out []Instruction
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	if len(out) != 2 {
+		t.Errorf("expected 2 instructions, got %d", len(out))
+	}
+	if out[0].Scope != "global" {
+		t.Errorf("first row scope: expected global, got %s", out[0].Scope)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsList_ByScope(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newGetRequest("/instructions?scope=global")
+	c.Request = httptest.NewRequest(http.MethodGet, "/instructions?scope=global", nil)
+
+	rows := sqlmock.NewRows(instructionCols).
+		AddRow("inst-g", "global", nil, "Global Rule", "Follow policy.", 10, true, time.Now(), time.Now())
+	mock.ExpectQuery("SELECT id, scope, scope_target, title, content, priority, enabled, created_at, updated_at FROM platform_instructions WHERE 1=1").
+		WithArgs("global").
+		WillReturnRows(rows)
+
+	h.List(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var out []Instruction
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	if len(out) != 1 || out[0].Scope != "global" {
+		t.Errorf("unexpected response: %v", out)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsList_AllNoParams(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newGetRequest("/instructions")
+
+	rows := sqlmock.NewRows(instructionCols)
+	mock.ExpectQuery("SELECT id, scope, scope_target, title, content, priority, enabled, created_at, updated_at FROM platform_instructions WHERE 1=1").
+		WillReturnRows(rows)
+
+	h.List(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var out []Instruction
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	// Empty slice, not nil
+	if out == nil {
+		t.Error("expected empty slice, got nil")
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsList_DBError(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newGetRequest("/instructions")
+	c.Request = httptest.NewRequest(http.MethodGet, "/instructions", nil)
+
+	mock.ExpectQuery("SELECT id, scope, scope_target, title, content, priority, enabled, created_at, updated_at FROM platform_instructions WHERE 1=1").
+		WillReturnError(errors.New("connection refused"))
+
+	h.List(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── Create ───────────────────────────────────────────────────────────────────
+
+func TestInstructionsCreate_ValidGlobal(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":    "global",
+		"title":    "Be Helpful",
+		"content":  "Always be helpful to the user.",
+		"priority": 10,
+	})
+
+	mock.ExpectQuery("INSERT INTO platform_instructions").
+		WithArgs("global", nil, "Be Helpful", "Always be helpful to the user.", 10).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("new-inst-1"))
+
+	h.Create(c)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+	var out map[string]string
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	if out["id"] != "new-inst-1" {
+		t.Errorf("expected id new-inst-1, got %s", out["id"])
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsCreate_ValidWorkspace(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+	wsTarget := "ws-xyz-789"
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":        "workspace",
+		"scope_target": wsTarget,
+		"title":        "Use Claude Code",
+		"content":      "Prefer Claude Code for all tasks.",
+		"priority":     5,
+	})
+
+	mock.ExpectQuery("INSERT INTO platform_instructions").
+		WithArgs("workspace", &wsTarget, "Use Claude Code", "Prefer Claude Code for all tasks.", 5).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("ws-inst-2"))
+
+	h.Create(c)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsCreate_MissingScope(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"title":   "Missing Scope",
+		"content": "This has no scope.",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_MissingTitle(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"content": "Has no title.",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_MissingContent(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope": "global",
+		"title": "Has no content",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_InvalidScope(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "team",
+		"title":   "Bad Scope",
+		"content": "Team scope is not supported yet.",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_WorkspaceScopeNoTarget(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "workspace",
+		"title":   "Missing Target",
+		"content": "Workspace scope without scope_target.",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_ContentTooLong(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	// Build a string longer than maxInstructionContentLen (8192).
+	longContent := string(make([]byte, maxInstructionContentLen+1))
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"title":   "Too Long",
+		"content": longContent,
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_TitleTooLong(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	longTitle := string(make([]byte, 201))
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"title":   longTitle,
+		"content": "Short content.",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsCreate_DBError(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"title":   "DB Error",
+		"content": "This will fail.",
+	})
+
+	mock.ExpectQuery("INSERT INTO platform_instructions").
+		WillReturnError(errors.New("connection refused"))
+
+	h.Create(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── Update ──────────────────────────────────────────────────────────────────
+
+func TestInstructionsUpdate_ValidPartial(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-update-1"
+	newTitle := "Updated Title"
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
+		"title": newTitle,
+	})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("UPDATE platform_instructions SET").
+		WithArgs(&newTitle, sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), instID).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h.Update(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsUpdate_AllFields(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-update-2"
+	title := "Full Update"
+	content := "New content body."
+	priority := 20
+	enabled := false
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
+		"title":    title,
+		"content":  content,
+		"priority": priority,
+		"enabled":  enabled,
+	})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("UPDATE platform_instructions SET").
+		WithArgs(&title, &content, &priority, &enabled, instID).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h.Update(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsUpdate_ContentTooLong(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-too-long"
+	longContent := string(make([]byte, maxInstructionContentLen+1))
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
+		"content": longContent,
+	})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	h.Update(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsUpdate_TitleTooLong(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-title-long"
+	longTitle := string(make([]byte, 201))
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
+		"title": longTitle,
+	})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	h.Update(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+func TestInstructionsUpdate_NotFound(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-missing"
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
+		"title": "New Title",
+	})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("UPDATE platform_instructions SET").
+		WillReturnResult(sqlmock.NewResult(0, 0))
+
+	h.Update(c)
+
+	if w.Code != http.StatusNotFound {
+		t.Fatalf("expected 404, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsUpdate_DBError(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-db-err"
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{
+		"title": "Error Update",
+	})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("UPDATE platform_instructions SET").
+		WillReturnError(errors.New("connection refused"))
+
+	h.Update(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── Delete ───────────────────────────────────────────────────────────────────
+
+func TestInstructionsDelete_Valid(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-delete-1"
+	w, c := newDeleteRequest("/instructions/" + instID)
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("DELETE FROM platform_instructions WHERE id = $1").
+		WithArgs(instID).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h.Delete(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsDelete_NotFound(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-not-there"
+	w, c := newDeleteRequest("/instructions/" + instID)
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("DELETE FROM platform_instructions WHERE id = $1").
+		WithArgs(instID).
+		WillReturnResult(sqlmock.NewResult(0, 0))
+
+	h.Delete(c)
+
+	if w.Code != http.StatusNotFound {
+		t.Fatalf("expected 404, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsDelete_DBError(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-del-err"
+	w, c := newDeleteRequest("/instructions/" + instID)
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	mock.ExpectExec("DELETE FROM platform_instructions WHERE id = $1").
+		WillReturnError(errors.New("connection refused"))
+
+	h.Delete(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── Resolve ──────────────────────────────────────────────────────────────────
+
+func TestInstructionsResolve_GlobalThenWorkspace(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	wsID := "ws-resolve-1"
+	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
+	c.Params = []gin.Param{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
+
+	now := time.Now()
+	rows := sqlmock.NewRows(resolveCols).
+		AddRow("global", "Be Helpful", "Always help the user.").
+		AddRow("global", "Stay on Topic", "Don't diverge.").
+		AddRow("workspace", "Use Claude Code", "Claude Code is the default runtime.")
+	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
+		WithArgs(wsID).
+		WillReturnRows(rows)
+
+	h.Resolve(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var out struct {
+		WorkspaceID   string `json:"workspace_id"`
+		Instructions string `json:"instructions"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	if out.WorkspaceID != wsID {
+		t.Errorf("expected workspace_id %s, got %s", wsID, out.WorkspaceID)
+	}
+	// Global section must come before workspace section.
+	if !bytes.Contains([]byte(out.Instructions), []byte("Platform-Wide Rules")) {
+		t.Error("instructions should contain 'Platform-Wide Rules' section")
+	}
+	if !bytes.Contains([]byte(out.Instructions), []byte("Role-Specific Rules")) {
+		t.Error("instructions should contain 'Role-Specific Rules' section")
+	}
+	// Global instructions must appear before workspace instructions.
+	idxGlobal := bytes.Index([]byte(out.Instructions), []byte("Platform-Wide Rules"))
+	idxWorkspace := bytes.Index([]byte(out.Instructions), []byte("Role-Specific Rules"))
+	if idxGlobal >= idxWorkspace {
+		t.Error("global section should appear before workspace section")
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsResolve_EmptyWorkspace(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	wsID := "ws-empty"
+	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
+	c.Params = []gin.Param{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
+
+	rows := sqlmock.NewRows(resolveCols)
+	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
+		WithArgs(wsID).
+		WillReturnRows(rows)
+
+	h.Resolve(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var out struct {
+		Instructions string `json:"instructions"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	// No rows → builder writes nothing; empty string returned.
+	if out.Instructions != "" {
+		t.Errorf("expected empty instructions for empty workspace, got: %q", out.Instructions)
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsResolve_DBError(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	wsID := "ws-err"
+	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
+	c.Params = []gin.Param{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
+
+	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
+		WithArgs(wsID).
+		WillReturnError(errors.New("connection refused"))
+
+	h.Resolve(c)
+
+	if w.Code != http.StatusInternalServerError {
+		t.Fatalf("expected 500, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+func TestInstructionsResolve_MissingWorkspaceID(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newGetRequest("/workspaces//instructions/resolve")
+	c.Params = []gin.Param{{Key: "id", Value: ""}}
+
+	h.Resolve(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+// ─── scanInstructions edge cases ───────────────────────────────────────────────
+
+func TestScanInstructions_ScanError(t *testing.T) {
+	// A mock rows object that returns a scan error on second row.
+	badRows := sqlmock.NewRows(instructionCols).
+		AddRow("inst-ok", "global", nil, "OK", "OK content", 10, true, time.Now(), time.Now()).
+		RowError(1, errors.New("scan error")).
+		AddRow("inst-bad", "global", nil, "Bad", "Bad content", 5, true, time.Now(), time.Now())
+
+	result := scanInstructions(badRows)
+	// First row should be captured; scan error is logged and skipped.
+	if len(result) != 1 || result[0].ID != "inst-ok" {
+		t.Errorf("expected 1 instruction (inst-ok), got: %v", result)
+	}
+}
+
+// ─── maxInstructionContentLen boundary ────────────────────────────────────────
+
+func TestInstructionsCreate_ContentExactlyAtLimit(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	exactContent := string(make([]byte, maxInstructionContentLen))
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"title":   "At Limit",
+		"content": exactContent,
+	})
+
+	mock.ExpectQuery("INSERT INTO platform_instructions").
+		WithArgs("global", nil, "At Limit", exactContent, 0).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("at-limit-1"))
+
+	h.Create(c)
+
+	// Exactly at limit must succeed (8192 chars is acceptable).
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201 for content at limit, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── priority defaults ────────────────────────────────────────────────────────
+
+func TestInstructionsCreate_PriorityDefaultsToZero(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	// Body omits priority — expect it defaults to 0.
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"title":   "No Priority",
+		"content": "Default priority body.",
+	})
+
+	mock.ExpectQuery("INSERT INTO platform_instructions").
+		WithArgs("global", nil, "No Priority", "Default priority body.", 0).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("no-prio-1"))
+
+	h.Create(c)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── nil scope_target for global instructions ─────────────────────────────────
+
+func TestInstructionsCreate_GlobalScopeNilTarget(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":   "global",
+		"title":   "Global Nil Target",
+		"content": "Global instruction.",
+	})
+
+	// For global scope, scope_target must be SQL NULL.
+	mock.ExpectQuery("INSERT INTO platform_instructions").
+		WithArgs("global", nil, "Global Nil Target", "Global instruction.", 0).
+		WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow("global-nil-1"))
+
+	h.Create(c)
+
+	if w.Code != http.StatusCreated {
+		t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── workspace scope with empty string target (rejected) ─────────────────────
+
+func TestInstructionsCreate_WorkspaceScopeEmptyStringTarget(t *testing.T) {
+	setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	empty := ""
+	w, c := newPostRequest("/instructions", map[string]interface{}{
+		"scope":        "workspace",
+		"scope_target": empty,
+		"title":        "Empty Target",
+		"content":      "Empty workspace target.",
+	})
+
+	h.Create(c)
+
+	if w.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for empty string scope_target, got %d: %s", w.Code, w.Body.String())
+	}
+}
+
+// ─── Resolve: scope label transitions ────────────────────────────────────────
+
+func TestInstructionsResolve_ScopeTransitionOnlyGlobal(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	wsID := "ws-only-global"
+	w, c := newGetRequest("/workspaces/" + wsID + "/instructions/resolve")
+	c.Params = []gin.Param{{Key: "id", Value: wsID}}
+	c.Request = httptest.NewRequest(http.MethodGet, "/workspaces/"+wsID+"/instructions/resolve", nil)
+
+	rows := sqlmock.NewRows(resolveCols).
+		AddRow("global", "Rule One", "First rule.").
+		AddRow("global", "Rule Two", "Second rule.")
+	mock.ExpectQuery("SELECT scope, title, content FROM platform_instructions").
+		WithArgs(wsID).
+		WillReturnRows(rows)
+
+	h.Resolve(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String())
+	}
+	var out struct {
+		Instructions string `json:"instructions"`
+	}
+	if err := json.Unmarshal(w.Body.Bytes(), &out); err != nil {
+		t.Fatalf("response not valid JSON: %v", err)
+	}
+	// Two global instructions share one section header.
+	if bytes.Count([]byte(out.Instructions), []byte("Platform-Wide Rules")) != 1 {
+		t.Error("expect exactly one 'Platform-Wide Rules' header for consecutive global rows")
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}
+
+// ─── Update: empty body (all nil — no-op update) ─────────────────────────────
+
+func TestInstructionsUpdate_EmptyBody(t *testing.T) {
+	mock := setupTestDB(t)
+	h := NewInstructionsHandler()
+
+	instID := "inst-empty-update"
+	w, c := newPutRequest("/instructions/"+instID, map[string]interface{}{})
+	c.Params = []gin.Param{{Key: "id", Value: instID}}
+
+	// COALESCE(nil, ...) = unchanged; still updates updated_at.
+	mock.ExpectExec("UPDATE platform_instructions SET").
+		WithArgs(sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), sqlmock.AnyArg(), instID).
+		WillReturnResult(sqlmock.NewResult(0, 1))
+
+	h.Update(c)
+
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200 for empty body, got %d: %s", w.Code, w.Body.String())
+	}
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("unmet expectations: %v", err)
+	}
+}

workspace-server/internal/handlers/org_helpers.go

@@ -317,12 +317,6 @@ func mergePlugins(defaultPlugins, wsPlugins []string) []string {
 // Follows Go's standard pattern for SSRF-class path sanitization; using
 // strings.HasPrefix on an absolute-path pair plus the separator guard rejects
 // sibling directories that share a prefix (e.g. "/foo" vs "/foobar").
-//
-// CWE-59 mitigation: filepath.Abs does NOT resolve symlinks, so a path like
-// "workspaces/dev/inner" where "inner" is a symlink to "/etc" would lexically
-// pass the prefix check. We call filepath.EvalSymlinks to canonicalize the
-// path and re-check that it is still inside root. This closes the symlink-
-// based traversal vector (CWE-59, follow-up to #369).
 func resolveInsideRoot(root, userPath string) (string, error) {
 	if userPath == "" {
 		return "", fmt.Errorf("path is empty")
@@ -339,18 +333,9 @@ func resolveInsideRoot(root, userPath string) (string, error) {
 	if err != nil {
 		return "", fmt.Errorf("joined abs: %w", err)
 	}
-	// CWE-59: resolve symlinks before final prefix check.
-	// If the path contains a symlink pointing outside root, EvalSymlinks
-	// will canonicalize to the external path and fail the guard below.
-	resolved, err := filepath.EvalSymlinks(absJoined)
-	if err != nil {
-		// If EvalSymlinks fails (e.g. broken symlink), fail closed —
-		// broken symlinks should not be used as org files.
-		return "", fmt.Errorf("resolve symlink: %w", err)
-	}
 	// Allow exact-root match (rare but valid) and any descendant.
-	if resolved != absRoot && !strings.HasPrefix(resolved, absRoot+string(filepath.Separator)) {
+	if absJoined != absRoot && !strings.HasPrefix(absJoined, absRoot+string(filepath.Separator)) {
 		return "", fmt.Errorf("path escapes root")
 	}
-	return absJoined, nil // return the lexical path, not the resolved one
+	return absJoined, nil
 }

workspace-server/internal/handlers/org_path_test.go

@@ -78,48 +78,6 @@ func TestResolveInsideRoot_RejectsPrefixSibling(t *testing.T) {
 	}
 }
 
-// TestResolveInsideRoot_RejectsSymlinkTraversal is a regression test for
-// CWE-59 (symlink-based path traversal). An attacker plants a symlink inside
-// the allowed directory that points outside; the function must reject it.
-func TestResolveInsideRoot_RejectsSymlinkTraversal(t *testing.T) {
-	tmp := t.TempDir()
-	// Create a subdirectory inside root.
-	inner := filepath.Join(tmp, "workspaces", "dev")
-	if err := os.MkdirAll(inner, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	// Plant a symlink that resolves outside root.
-	sym := filepath.Join(inner, "leaked")
-	if err := os.Symlink("/etc", sym); err != nil {
-		t.Fatal(err)
-	}
-
-	// Lexically, "workspaces/dev/leaked" is inside tmp — but after symlink
-	// resolution it points to /etc and must be rejected.
-	if _, err := resolveInsideRoot(tmp, filepath.Join("workspaces", "dev", "leaked")); err == nil {
-		t.Error("symlink pointing outside root must be rejected (CWE-59)")
-	}
-
-	// Symlink that stays inside root is fine.
-	safe := filepath.Join(inner, "safe")
-	if err := os.Symlink(filepath.Join(tmp, "other"), safe); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := resolveInsideRoot(tmp, filepath.Join("workspaces", "dev", "safe")); err != nil {
-		t.Errorf("symlink staying inside root must be allowed: %v", err)
-	}
-
-	// Broken symlink (target does not exist) must also be rejected — broken
-	// symlinks cannot be valid org files.
-	broken := filepath.Join(inner, "broken")
-	if err := os.Symlink("/nonexistent/broken", broken); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := resolveInsideRoot(tmp, filepath.Join("workspaces", "dev", "broken")); err == nil {
-		t.Error("broken symlink must be rejected")
-	}
-}
-
 func TestResolveInsideRoot_DeepSubpath(t *testing.T) {
 	tmp := t.TempDir()
 	deep := filepath.Join(tmp, "a", "b", "c")

workspace/a2a_tools_delegation.py

@@ -47,7 +47,6 @@ from a2a_client import (
     send_a2a_message,
 )
 from a2a_tools_rbac import auth_headers_for_heartbeat as _auth_headers_for_heartbeat
-from _sanitize_a2a import sanitize_a2a_result
 
 
 # RFC #2829 PR-5 cutover constants. The poll cadence + timeout are
@@ -414,11 +413,7 @@ async def tool_check_task_status(
                 # Filter by delegation_id
                 matching = [d for d in delegations if d.get("delegation_id") == task_id]
                 if matching:
-                    # OFFSEC-003: sanitize peer-supplied fields
-                    d = matching[0]
-                    d["summary"] = sanitize_a2a_result(d.get("summary", ""))
-                    d["response_preview"] = sanitize_a2a_result(d.get("response_preview", ""))
-                    return json.dumps(d)
+                    return json.dumps(matching[0])
                 return json.dumps({"status": "not_found", "delegation_id": task_id})
             # Return all recent delegations
             summary = []
@@ -427,9 +422,8 @@ async def tool_check_task_status(
                     "delegation_id": d.get("delegation_id", ""),
                     "target_id": d.get("target_id", ""),
                     "status": d.get("status", ""),
-                    # OFFSEC-003: sanitize peer-supplied fields before embedding in JSON
-                    "summary": sanitize_a2a_result(d.get("summary", "")),
-                    "response_preview": sanitize_a2a_result(d.get("response_preview", "")),
+                    "summary": d.get("summary", ""),
+                    "response_preview": d.get("response_preview", ""),
                 })
             return json.dumps({"delegations": summary, "count": len(delegations)})
     except Exception as e:

workspace/main.py

@@ -668,31 +668,6 @@ async def main():  # pragma: no cover
                 if heartbeat.active_tasks > 0:
                     continue
 
-                # Issue #381 fix: skip the idle prompt if there are unconsumed
-                # delegation results waiting. The heartbeat sends a self-message
-                # for every new result batch, so sending the idle prompt here would
-                # race: the agent would compose a stale tick BEFORE processing the
-                # results notification, producing repeated identical asks (peer sends
-                # correction, we respond with stale state, peer asks again).
-                # By skipping the idle prompt when results are pending, we let the
-                # heartbeat's own self-message wake the agent after results are
-                # written. The agent then sees the results in _prepare_prompt()
-                # and processes them before composing.
-                from heartbeat import DELEGATION_RESULTS_FILE as _DRF
-                try:
-                    with open(_DRF) as _rf:
-                        _rf.seek(0)
-                        _content = _rf.read().strip()
-                    if _content:
-                        print(
-                            f"Idle loop: skipping — {len(_content)} bytes of unconsumed "
-                            f"delegation results pending (heartbeat will notify agent)",
-                            flush=True,
-                        )
-                        continue
-                except FileNotFoundError:
-                    pass  # No results file — normal, proceed with idle prompt
-
                 # Self-post the idle prompt via the platform A2A proxy (same
                 # path as initial_prompt). The agent's own concurrency control
                 # rejects if the workspace becomes busy between this check and

workspace/tests/test_idle_loop_pending_check.py

@@ -1,80 +0,0 @@
-"""Tests for issue #381: idle loop must not fire when delegation results are pending.
-
-The idle loop skips sending the idle prompt when DELEGATION_RESULTS_FILE
-contains unconsumed results, preventing the agent from composing a stale tick
-before processing pending delegation notifications from the heartbeat.
-
-Source: workspace/main.py:_run_idle_loop() pending-results guard.
-"""
-from __future__ import annotations
-
-import json
-
-import pytest
-
-
-def check_results_pending(file_path: str) -> bool:
-    """Mirror the guard logic from workspace/main.py:_run_idle_loop().
-
-    Returns True if the results file exists and is non-empty,
-    meaning the idle loop should skip this tick.
-    """
-    try:
-        with open(file_path) as rf:
-            rf.seek(0)
-            content = rf.read().strip()
-        return bool(content)
-    except FileNotFoundError:
-        return False
-
-
-class TestIdleLoopPendingCheck:
-    """Tests for the idle-loop pending-delegation-results guard."""
-
-    def test_no_file_means_proceed(self, tmp_path):
-        """No delegation results file → idle loop fires normally."""
-        results_file = tmp_path / "delegation_results.jsonl"
-        assert not check_results_pending(str(results_file))
-
-    def test_empty_file_means_proceed(self, tmp_path):
-        """Empty file → no pending results → idle loop fires."""
-        results_file = tmp_path / "delegation_results.jsonl"
-        results_file.write_text("", encoding="utf-8")
-        assert not check_results_pending(str(results_file))
-
-    def test_whitespace_only_file_means_proceed(self, tmp_path):
-        """File with only whitespace → treated as empty → idle loop fires."""
-        results_file = tmp_path / "delegation_results.jsonl"
-        results_file.write_text("  \n  ", encoding="utf-8")
-        assert not check_results_pending(str(results_file))
-
-    def test_single_result_means_skip(self, tmp_path):
-        """File with one delegation result → skip idle tick."""
-        results_file = tmp_path / "delegation_results.jsonl"
-        results_file.write_text(
-            json.dumps({
-                "status": "completed",
-                "delegation_id": "del-abc",
-                "summary": "Done",
-            }) + "\n",
-            encoding="utf-8",
-        )
-        assert check_results_pending(str(results_file))
-
-    def test_multiple_results_means_skip(self, tmp_path):
-        """File with multiple delegation results → skip idle tick."""
-        results_file = tmp_path / "delegation_results.jsonl"
-        results_file.write_text(
-            json.dumps({"status": "completed", "delegation_id": "del-1", "summary": "A"})
-            + "\n"
-            + json.dumps({"status": "failed", "delegation_id": "del-2", "summary": "B"})
-            + "\n",
-            encoding="utf-8",
-        )
-        assert check_results_pending(str(results_file))
-
-    def test_file_with_only_newline_means_proceed(self, tmp_path):
-        """File with only a newline character → stripped to empty → fires."""
-        results_file = tmp_path / "delegation_results.jsonl"
-        results_file.write_text("\n", encoding="utf-8")
-        assert not check_results_pending(str(results_file))