Reuse Session executors through a shared Harness contract

README.md

@@ -76,6 +76,7 @@ native differences.
 | [API reference](docs/api/README.md) | The `/v1`, `/core/v1` and `/api/v1` namespaces |
 | [Nodes and sandbox backends: operator reference](services/agents-api/HOSTED-SANDBOX-MANAGER.md) | Node protocol, manual registration, placement, maintenance |
 | [Protocol coverage](contracts/agents-api/README.md) and [harness selection](contracts/agents-api/harness-selection.md) | Supported operations and native differences |
+| [Add a Harness](contracts/agents-api/harness-onboarding.md) | Required adapter interfaces, lifecycle, capabilities, registration and acceptance |
 | [Landing page source](site/index.html) | The public site |
 
 ### Maintainers and advanced deployments

apps/parsar-daemon/internal/agent/claudesdk/cancellation.go

@@ -2,28 +2,51 @@ package claudesdk
 
 import (
 	"context"
+	"errors"
+	"github.com/MiniMax-AI-Dev/parsar/apps/parsar-daemon/internal/agent"
 
 	"github.com/MiniMax-AI-Dev/parsar/internal/agentdaemon/proto"
 )
 
-// Cancel confirms process exit and output drain, independently of terminal delivery.
+// Cancel addresses this fixed Turn. Settlement remains observable after the caller detaches.
 func (s *session) Cancel(ctx context.Context) error {
 	if ctx == nil {
 		ctx = context.Background()
 	}
 	select {
 	case <-s.settled:
-		return nil
+		return s.settlementErr
 	default:
 	}
-	s.process.Cancel()
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	if s.owner == nil {
+		return errors.New("claudesdk: Turn owner is unavailable")
+	}
+	s.cancelOnce.Do(func() {
+		close(s.cancelOutput)
+		s.owner.mu.Lock()
+		current := s.owner.active == s && !s.owner.invalid
+		s.owner.mu.Unlock()
+		if current {
+			stopWrite := context.AfterFunc(ctx, s.invalidate)
+			defer stopWrite()
+			if err := s.owner.write(struct {
+				Type   string `json:"type"`
+				TurnID string `json:"turn_id"`
+			}{"turn_cancel", s.runID}); err != nil {
+				s.invalidate()
+			}
+		}
+	})
 	select {
 	case <-s.settled:
-		return nil
+		return s.settlementErr
 	case <-ctx.Done():
 		select {
 		case <-s.settled:
-			return nil
+			return s.settlementErr
 		default:
 			return ctx.Err()
 		}
@@ -40,3 +63,5 @@ func (s *session) CancellationOutcome() proto.DonePayload {
 		return proto.DonePayload{}
 	}
 }
+
+var _ agent.Turn = (*session)(nil)

apps/parsar-daemon/internal/agent/claudesdk/cancellation_test.go

@@ -3,16 +3,15 @@
 package claudesdk
 
 import (
+	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"os"
-	"os/signal"
 	"path/filepath"
 	"reflect"
 	"strings"
-	"syscall"
 	"testing"
 	"time"
 
@@ -171,12 +170,16 @@ func cancellationRequest() proto.PromptRequestPayload {
 	return proto.PromptRequestPayload{RunID: "run", Input: proto.TextInput("hello"), AgentSessionID: "native-session", AgentOptions: map[string]any{"model": "fake-model", "system_prompt": "instructions"}}
 }
 
-func runCancellationHelper(request startRequest, mode string, emit func(bridgeEvent)) {
+func runCancellationHelper(request startRequest, mode string, scanner *bufio.Scanner, emit func(bridgeEvent)) {
 	if mode == "cancellation-wait" {
-		stopped := make(chan os.Signal, 1)
-		signal.Notify(stopped, syscall.SIGTERM)
 		emit(bridgeEvent{Type: "delta", Delta: "partial"})
-		<-stopped
+		if !scanner.Scan() {
+			return
+		}
+		var cancel map[string]any
+		if json.Unmarshal(scanner.Bytes(), &cancel) != nil || cancel["type"] != "turn_cancel" {
+			os.Exit(9)
+		}
 		// These valid observations were in flight when cancellation started.
 		emit(bridgeEvent{Type: "input_ready", SessionID: request.Resume})
 		emit(bridgeEvent{Type: "usage", ResultID: "native-result", SessionID: request.Resume, Usage: json.RawMessage(usageFixture)})
@@ -189,6 +192,8 @@ func runCancellationHelper(request startRequest, mode string, emit func(bridgeEv
 		}
 		_, _ = os.Stderr.WriteString(strings.Repeat("x", 2*1024*1024))
 		emit(bridgeEvent{Type: "delta", Delta: "drained"})
+		emit(bridgeEvent{Type: "input_closed", SessionID: request.Resume})
+		emit(bridgeEvent{Type: "error", Code: "cancelled"})
 		return
 	}
 	if mode != "cancellation-before-identity" {

apps/parsar-daemon/internal/agent/claudesdk/commands_session_test.go

@@ -3,10 +3,10 @@
 package claudesdk
 
 import (
+	"bufio"
 	"context"
 	"encoding/json"
 	"os"
-	"os/signal"
 	"path/filepath"
 	"strings"
 	"syscall"
@@ -119,8 +119,8 @@ func TestWorkspaceCommandCancellationAndBridgeFailuresCloseOnlyPendingCalls(t *t
 								t.Fatal(err)
 							}
 						} else if mode == "commands-cancel" || mode == "commands-drained" {
-							if err := s.Cancel(ctx); err != nil {
-								t.Fatal(err)
+							if err := s.Cancel(ctx); (err == nil) != (mode == "commands-drained") {
+								t.Fatalf("command cancellation confirmation: %v", err)
 							}
 						}
 					}
@@ -155,13 +155,7 @@ func TestWorkspaceCommandCancellationAndBridgeFailuresCloseOnlyPendingCalls(t *t
 	}
 }
 
-func runCommandsHelper(request startRequest, mode string, emit func(bridgeEvent)) {
-	var stopping chan os.Signal
-	if mode == "commands-cancel" || mode == "commands-drained" {
-		stopping = make(chan os.Signal, 1)
-		signal.Notify(stopping, syscall.SIGTERM)
-		defer signal.Stop(stopping)
-	}
+func runCommandsHelper(request startRequest, mode string, scanner *bufio.Scanner, emit func(bridgeEvent)) {
 	if mode != "commands-before-ready" {
 		emit(bridgeEvent{Type: "input_ready", SessionID: request.Resume})
 	}
@@ -181,7 +175,9 @@ func runCommandsHelper(request startRequest, mode string, emit func(bridgeEvent)
 	}
 	switch mode {
 	case "commands-cancel", "commands-drained":
-		<-stopping
+		if !scanner.Scan() {
+			return
+		}
 		if mode == "commands-drained" {
 			interrupted := commandEvent("pending", "after", "incomplete", "sleep 30")
 			interrupted.Observation.Output = json.RawMessage(`"observed while draining"`)