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/corpus_test.go

View on GitHub
package runtime

import (
	"context"
	"errors"
	"fmt"
	"reflect"
	"sync"
	"testing"
	"time"

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

// A written ref resolves to its value; an unwritten ref reports ok == false.
func TestCorpus_RefResolvesAndMissingIsAbsent(t *testing.T) {
	c := NewCorpus(nil) // LastWriteWins
	ref := sketch.MemoryRef{Namespace: "docs", Key: "report"}

	if _, ok, _ := c.Get(context.Background(), ref); ok {
		t.Fatal("an unwritten ref should report ok=false")
	}
	if err := c.Merge(context.Background(), ref, "full text"); err != nil {
		t.Fatalf("Merge: %v", err)
	}
	v, ok, err := c.Get(context.Background(), ref)
	if err != nil || !ok {
		t.Fatalf("Get: ok=%v err=%v", ok, err)
	}
	if v.(string) != "full text" {
		t.Fatalf("Get = %q, want %q", v, "full text")
	}
}

func TestCorpus_GetReturnsContextError(t *testing.T) {
	c := NewCorpus(nil)
	ref := sketch.MemoryRef{Namespace: "docs", Key: "report"}
	if err := c.Merge(context.Background(), ref, "full text"); err != nil {
		t.Fatalf("Merge: %v", err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	if v, ok, err := c.Get(ctx, ref); !errors.Is(err, context.Canceled) || ok || v != nil {
		t.Fatalf("Get with canceled context = (%v, %v, %v), want nil/false/context.Canceled", v, ok, err)
	}

	expired, cancelExpired := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
	defer cancelExpired()
	if _, _, err := c.Get(expired, ref); !errors.Is(err, context.DeadlineExceeded) {
		t.Fatalf("Get with expired context err = %v, want context.DeadlineExceeded", err)
	}
}

func TestCorpus_MergeReturnsContextErrorAndDoesNotMutate(t *testing.T) {
	c := NewCorpus(nil)
	ref := sketch.MemoryRef{Namespace: "docs", Key: "report"}
	missing := sketch.MemoryRef{Namespace: "docs", Key: "missing"}
	if err := c.Merge(context.Background(), ref, "original"); err != nil {
		t.Fatalf("initial Merge: %v", err)
	}

	ctx, cancel := context.WithCancel(context.Background())
	cancel()
	if err := c.Merge(ctx, ref, "mutated"); !errors.Is(err, context.Canceled) {
		t.Fatalf("Merge with canceled context err = %v, want context.Canceled", err)
	}
	if err := c.Merge(ctx, missing, "inserted"); !errors.Is(err, context.Canceled) {
		t.Fatalf("Merge missing with canceled context err = %v, want context.Canceled", err)
	}

	v, ok, err := c.Get(context.Background(), ref)
	if err != nil || !ok {
		t.Fatalf("Get after canceled Merge: ok=%v err=%v", ok, err)
	}
	if v != "original" {
		t.Fatalf("canceled Merge mutated stored value: got %q, want original", v)
	}
	if _, ok, err := c.Get(context.Background(), missing); err != nil || ok {
		t.Fatalf("canceled Merge inserted missing ref: ok=%v err=%v", ok, err)
	}
}

func TestCorpus_MemoryRefKeyFieldsCannotCollide(t *testing.T) {
	c := NewCorpus(nil)
	a := sketch.MemoryRef{Namespace: "docs", Key: "report\x00draft"}
	b := sketch.MemoryRef{Namespace: "docs\x00report", Key: "draft"}

	if err := c.Merge(context.Background(), a, "value-a"); err != nil {
		t.Fatalf("Merge(a): %v", err)
	}
	if err := c.Merge(context.Background(), b, "value-b"); err != nil {
		t.Fatalf("Merge(b): %v", err)
	}

	av, ok, err := c.Get(context.Background(), a)
	if err != nil || !ok {
		t.Fatalf("Get(a): ok=%v err=%v", ok, err)
	}
	bv, ok, err := c.Get(context.Background(), b)
	if err != nil || !ok {
		t.Fatalf("Get(b): ok=%v err=%v", ok, err)
	}
	if av != "value-a" {
		t.Fatalf("Get(a) = %q, want value-a", av)
	}
	if bv != "value-b" {
		t.Fatalf("Get(b) = %q, want value-b", bv)
	}
}

// The conflict-free claim: with a commutative MergeFunc the final value does not
// depend on the order writes arrived in. Two corpora fed the same set of writes
// in different orders converge to the same union.
func TestCorpus_UnionMergeIsCommutative(t *testing.T) {
	ref := sketch.MemoryRef{Namespace: "tags", Key: "set"}
	want := []string{"x", "y", "z"}

	a := NewCorpus(UnionStrings)
	for _, s := range []string{"x", "y", "z"} {
		if err := a.Merge(context.Background(), ref, s); err != nil {
			t.Fatalf("a.Merge(%q): %v", s, err)
		}
	}
	b := NewCorpus(UnionStrings)
	for _, s := range []string{"z", "x", "y"} { // different order, same set
		if err := b.Merge(context.Background(), ref, s); err != nil {
			t.Fatalf("b.Merge(%q): %v", s, err)
		}
	}

	av, _, _ := a.Get(context.Background(), ref)
	bv, _, _ := b.Get(context.Background(), ref)
	if !reflect.DeepEqual(av, want) {
		t.Fatalf("order x,y,z converged to %v, want %v", av, want)
	}
	if !reflect.DeepEqual(bv, want) {
		t.Fatalf("order z,x,y converged to %v, want %v", bv, want)
	}
	if !reflect.DeepEqual(av, bv) {
		t.Fatalf("merge is not commutative: %v != %v (order changed the result)", av, bv)
	}
}

// Concurrent Merges of the same key are conflict-free under -race: every writer's
// value is present and none is lost, with no corruption.
func TestCorpus_ConcurrentUnionMergeIsConflictFree(t *testing.T) {
	const writers = 16
	c := NewCorpus(UnionStrings)
	ref := sketch.MemoryRef{Namespace: "tags", Key: "set"}

	var wg sync.WaitGroup
	for i := 0; i < writers; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			_ = c.Merge(context.Background(), ref, fmt.Sprintf("w%02d", i))
		}(i)
	}
	wg.Wait()

	v, ok, _ := c.Get(context.Background(), ref)
	if !ok {
		t.Fatal("ref absent after concurrent merges")
	}
	got := v.([]string)
	if len(got) != writers {
		t.Fatalf("got %d values, want %d (a concurrent write was lost)", len(got), writers)
	}
}

func TestCorpus_StringSliceDoesNotLeakThroughGet(t *testing.T) {
	c := NewCorpus(nil)
	ref := sketch.MemoryRef{Namespace: "tags", Key: "set"}
	if err := c.Merge(context.Background(), ref, []string{"a", "b"}); err != nil {
		t.Fatalf("Merge: %v", err)
	}

	v, ok, err := c.Get(context.Background(), ref)
	if err != nil || !ok {
		t.Fatalf("Get: ok=%v err=%v", ok, err)
	}
	got := v.([]string)
	got[0] = "mutated"

	v, _, _ = c.Get(context.Background(), ref)
	if got := v.([]string); !reflect.DeepEqual(got, []string{"a", "b"}) {
		t.Fatalf("stored slice mutated through Get result: %v", got)
	}
}

func TestCorpus_StringSliceDoesNotLeakThroughMergeDelta(t *testing.T) {
	c := NewCorpus(nil)
	ref := sketch.MemoryRef{Namespace: "tags", Key: "set"}
	delta := []string{"a", "b"}
	if err := c.Merge(context.Background(), ref, delta); err != nil {
		t.Fatalf("Merge: %v", err)
	}
	delta[0] = "mutated"

	v, _, _ := c.Get(context.Background(), ref)
	if got := v.([]string); !reflect.DeepEqual(got, []string{"a", "b"}) {
		t.Fatalf("stored slice mutated through original delta: %v", got)
	}
}

func TestCorpus_MergeFuncCannotMutateExistingOnError(t *testing.T) {
	boom := errors.New("boom")
	c := NewCorpus(func(existing any, ok bool, delta any) (any, error) {
		if ok {
			existing.([]string)[0] = "mutated"
			return nil, boom
		}
		return delta, nil
	})
	ref := sketch.MemoryRef{Namespace: "tags", Key: "set"}
	if err := c.Merge(context.Background(), ref, []string{"a", "b"}); err != nil {
		t.Fatalf("initial Merge: %v", err)
	}
	if err := c.Merge(context.Background(), ref, "c"); !errors.Is(err, boom) {
		t.Fatalf("second Merge err = %v, want boom", err)
	}

	v, _, _ := c.Get(context.Background(), ref)
	if got := v.([]string); !reflect.DeepEqual(got, []string{"a", "b"}) {
		t.Fatalf("stored slice mutated by failed merge: %v", got)
	}
}
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