Skip to content

dyngai/handoffkit / plugins/handoffkit/skills/handoffkit-scaffold

handoffkit-scaffold

Verified

Built by DynG AI for PlatformPilot.ai-style Go agent runtimes. Use when the user wants to scaffold HandoffKit runtime primitives into a Go project: channel-backed mailboxes, select, router, broker, join/quorum barriers, trace, budget, corpus/compactor, supervisor/nursery, dead letters, and sketch interfaces. Trigger words include PlatformPilot scaffold, scaffold handoffkit, add the HandoffKit runtime, set up message-passing agents, or drop in CSP agent primitives.

references/_src/runtime/mailbox_test.go

View on GitHub
package runtime

import (
	"context"
	"errors"
	"testing"
	"time"

	"github.com/dyngai/handoffkit/sketch"
)

// A negative buffer is clamped to 0 (unbuffered) rather than panicking in
// make(). Proven by behavior: an unbuffered Send with no receiver blocks until
// the context deadline, if it had been given a positive buffer, Send would
// succeed immediately.
func TestNewMailbox_NegativeBufferClampedToZero(t *testing.T) {
	mb := NewMailbox(-5) // must not panic

	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer cancel()

	err := mb.Send(ctx, sketch.Msg{Payload: "x"})
	if !errors.Is(err, context.DeadlineExceeded) {
		t.Fatalf("Send on unbuffered mailbox with no receiver: err = %v, want context.DeadlineExceeded", err)
	}
}

// Close is idempotent: a double close must not panic.
func TestChanMailbox_DoubleCloseNoPanic(t *testing.T) {
	mb := NewMailbox(1)
	if err := mb.Close(); err != nil {
		t.Fatalf("Close: %v", err)
	}
	if err := mb.Close(); err != nil {
		t.Fatalf("second Close: %v", err)
	}
}

// Send after Close returns ErrClosed instead of panicking with send-on-closed.
func TestChanMailbox_SendAfterCloseReturnsError(t *testing.T) {
	mb := NewMailbox(1)
	if err := mb.Close(); err != nil {
		t.Fatalf("Close: %v", err)
	}
	if err := mb.Send(context.Background(), sketch.Msg{Payload: "x"}); !errors.Is(err, ErrClosed) {
		t.Fatalf("Send after Close: err = %v, want ErrClosed", err)
	}
}

// Send tolerates a nil context (treated as context.Background()) and does not
// mislabel it as ErrClosed.
func TestChanMailbox_SendNilContext(t *testing.T) {
	mb := NewMailbox(1)
	if err := mb.Send(nil, sketch.Msg{Payload: "x"}); err != nil {
		t.Fatalf("Send(nil ctx): %v", err)
	}
	if m, ok, err := mb.Recv(context.Background()); err != nil || !ok || m.Payload != "x" {
		t.Fatalf("Recv = (%q, %v, %v)", m.Payload, ok, err)
	}
}

// Recv tolerates a nil context (treated as context.Background()) without panic.
func TestChanMailbox_RecvNilContext(t *testing.T) {
	mb := NewMailbox(1)
	if err := mb.Send(context.Background(), sketch.Msg{Payload: "x"}); err != nil {
		t.Fatalf("Send: %v", err)
	}
	if m, ok, err := mb.Recv(nil); err != nil || !ok || m.Payload != "x" {
		t.Fatalf("Recv(nil ctx) = (%q, %v, %v)", m.Payload, ok, err)
	}
}

func TestChanMailbox_SendCanceledContextWinsOverReadyBuffer(t *testing.T) {
	mb := NewMailbox(1)
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	err := mb.Send(ctx, sketch.Msg{Payload: "canceled"})
	if !errors.Is(err, context.Canceled) {
		t.Fatalf("Send with canceled context: err = %v, want context.Canceled", err)
	}
	if _, ok := tryRecv(mb); ok {
		t.Fatal("Send delivered into a ready buffer despite an already-canceled context")
	}
	if err := mb.Send(context.Background(), sketch.Msg{Payload: "after"}); err != nil {
		t.Fatalf("Send after canceled attempt: %v", err)
	}
}

func TestChanMailbox_RecvCanceledContextWinsOverReadyBuffer(t *testing.T) {
	mb := NewMailbox(1)
	if err := mb.Send(context.Background(), sketch.Msg{Payload: "queued"}); err != nil {
		t.Fatalf("Send: %v", err)
	}
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	msg, ok, err := mb.Recv(ctx)
	if !errors.Is(err, context.Canceled) || ok {
		t.Fatalf("Recv with canceled context = (%q, %v, %v), want context.Canceled and ok=false", msg.Payload, ok, err)
	}
	msg, ok, err = mb.Recv(context.Background())
	if err != nil || !ok || msg.Payload != "queued" {
		t.Fatalf("Recv after canceled attempt = (%q, %v, %v), want queued message", msg.Payload, ok, err)
	}
}
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall