@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/channels/session_test.go

@@ -0,0 +1,108 @@
+package channels_test
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/channels"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+)
+
+// Twins of the "session chat aggregation" describe of upstream test/session-summary.test.ts.
+
+const (
+	start = "2025-01-01T00:00:00.000Z"
+	end   = "2025-01-01T00:00:01.000Z"
+)
+
+func summary(resource string, status ahptypes.SessionStatus, modifiedAt string) ahptypes.ChatSummary {
+	return ahptypes.ChatSummary{Resource: resource, Title: resource, Status: status, ModifiedAt: modifiedAt}
+}
+
+func withActivity(s ahptypes.ChatSummary, activity string) ahptypes.ChatSummary {
+	s.Activity = &activity
+	return s
+}
+
+func sessionState(chats ...ahptypes.ChatSummary) *ahptypes.SessionState {
+	return &ahptypes.SessionState{
+		Provider: "pi", Title: "Session", Status: ahptypes.SessionStatusIdle, Lifecycle: ahptypes.SessionLifecycleReady,
+		ActiveClients: []ahptypes.SessionActiveClient{}, Chats: chats,
+	}
+}
+
+func sp(s string) *string { return &s }
+
+func check(t *testing.T, got channels.SessionChatAggregate, status ahptypes.SessionStatus, activity *string, modifiedAt string) {
+	t.Helper()
+	want := channels.SessionChatAggregate{Status: status, Activity: activity, ModifiedAt: modifiedAt}
+	if !reflect.DeepEqual(got, want) {
+		gj, _ := json.Marshal(got)
+		wj, _ := json.Marshal(want)
+		t.Fatalf("aggregate = %s, want %s", gj, wj)
+	}
+}
+
+func TestSessionChatAggregation(t *testing.T) {
+	twin.Run(t, "session-summary", "passes through single-chat activity but preserves session-owned and unknown flags", func(t *testing.T) {
+		flags := ahptypes.SessionStatusIsRead | ahptypes.SessionStatusIsArchived | (1 << 10)
+		for _, status := range []ahptypes.SessionStatus{
+			ahptypes.SessionStatusIdle, ahptypes.SessionStatusInProgress, ahptypes.SessionStatusError, ahptypes.SessionStatusInputNeeded,
+		} {
+			state := sessionState(withActivity(summary("chat", status, start), "Working"))
+			state.Status = ahptypes.SessionStatusIdle | flags
+			before, _ := json.Marshal(state)
+			check(t, channels.AggregateSessionChats(state), status|flags, sp("Working"), start)
+			after, _ := json.Marshal(state)
+			if string(before) != string(after) {
+				t.Fatal("projection must not mutate source state")
+			}
+		}
+		state := sessionState(summary("chat", ahptypes.SessionStatusIdle|ahptypes.SessionStatusIsRead, start))
+		if got := channels.AggregateSessionChats(state).Status; got != ahptypes.SessionStatusIdle {
+			t.Fatalf("chat flags must not leak into the session; status = %d", got)
+		}
+	})
+
+	twin.Run(t, "session-summary", "uses default chat activity but the latest timestamp, comparing instants rather than strings", func(t *testing.T) {
+		recent := "2024-12-31T19:01:00-05:00"
+		state := sessionState(
+			withActivity(summary("default", ahptypes.SessionStatusIdle, start), "Default"),
+			withActivity(summary("recent", ahptypes.SessionStatusInProgress, recent), "Recent"),
+		)
+		state.DefaultChat = sp("default")
+		check(t, channels.AggregateSessionChats(state), ahptypes.SessionStatusIdle, sp("Default"), recent)
+		for _, defaultChat := range []*string{nil, sp("missing")} {
+			state.DefaultChat = defaultChat
+			check(t, channels.AggregateSessionChats(state), ahptypes.SessionStatusInProgress, sp("Recent"), recent)
+		}
+	})
+
+	twin.Run(t, "session-summary", "promotes Error and InputNeeded, preferring the most recent blocker of the winning kind", func(t *testing.T) {
+		state := sessionState(summary("default", ahptypes.SessionStatusIdle, start), withActivity(summary("error", ahptypes.SessionStatusError, start), "Error"))
+		state.DefaultChat = sp("default")
+		check(t, channels.AggregateSessionChats(state), ahptypes.SessionStatusError, sp("Error"), start)
+		state.Chats = append(state.Chats,
+			summary("old-input", ahptypes.SessionStatusInputNeeded, start),
+			withActivity(summary("input", ahptypes.SessionStatusInputNeeded, end), "Approval"))
+		check(t, channels.AggregateSessionChats(state), ahptypes.SessionStatusInputNeeded, sp("Approval"), end)
+	})
+
+	twin.Run(t, "session-summary", "handles an empty catalogue and chooses stable ties and valid timestamps", func(t *testing.T) {
+		empty := sessionState()
+		empty.Activity = sp("Starting")
+		check(t, channels.AggregateSessionChats(empty), ahptypes.SessionStatusIdle, sp("Starting"), "")
+		if got := channels.SessionSummaryOf("session", start, empty, nil).ModifiedAt; got != start {
+			t.Fatalf("modifiedAt = %s", got)
+		}
+		state := sessionState(
+			withActivity(summary("invalid", ahptypes.SessionStatusIdle, "invalid"), "Invalid"),
+			withActivity(summary("first", ahptypes.SessionStatusInProgress, start), "First"),
+			withActivity(summary("tie", ahptypes.SessionStatusIdle, start), "Tie"),
+		)
+		check(t, channels.AggregateSessionChats(state), ahptypes.SessionStatusInProgress, sp("First"), start)
+	})
+}

package/extensions/ahp/internal/compose/compose.go

@@ -0,0 +1,153 @@
+// Package compose is the composition root (port of src/host/pi-host.ts createPiHost): it builds
+// a host and wires the independently tested services to it. Nothing here opens a socket; the
+// caller decides whether and where to listen.
+package compose
+
+import (
+	"errors"
+	"sync"
+
+	ahptypes "github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/svc"
+)
+
+// MentionTrigger is the character that starts a file mention in a message.
+const MentionTrigger = "@"
+
+// FilesystemOptions opts a client into browsing and editing files (resources and watches). The
+// remote filesystem is never exposed unless this is given: Roots confine every path, and
+// Unrestricted is the explicit way to drop the confinement.
+type FilesystemOptions struct {
+	Roots        []string
+	Unrestricted bool
+}
+
+// TerminalOptions opts a client into shells on this machine.
+type TerminalOptions struct {
+	Shell string
+	Spawn svc.PtySpawner // nil = the real PTY
+}
+
+// Options configure Build.
+type Options struct {
+	ServerInfo       *ahptypes.Implementation
+	WorkingDirectory string
+	// Models lists the models offered to clients; nil or empty means none.
+	Models func() []pi.Model
+	// SessionRoot is where Pi's session files live, for the catalogue and hydration.
+	SessionRoot string
+	// CreateSessionManager is the storage for sessions created through the host.
+	CreateSessionManager pi.SessionManagerFactory
+	CreateBackend        pi.BackendFactory
+	DefaultSelection     func() *ahptypes.ModelSelection
+	DeleteFile           func(path string) (pi.SessionFileDeletionResult, error)
+	// WrapStore replaces the store of a session hydrated from disk (see pi.HydratorOptions).
+	WrapStore func(sessionID string, opened pi.SessionStore) pi.SessionStore
+	// AdoptForeignTurns mirrors prompts typed into the session locally into its chat.
+	AdoptForeignTurns  bool
+	AgentDir           string
+	ProjectTrustPolicy pi.ProjectTrustPolicy
+	Log                func(format string, args ...any)
+
+	// Filesystem and Terminals are nil unless the user opted in.
+	Filesystem *FilesystemOptions
+	Terminals  *TerminalOptions
+}
+
+// Built is the composed host and the services a caller may need to reach or shut down.
+type Built struct {
+	Host      *host.Host
+	Sessions  *pi.Services
+	Resources *svc.ResourceService // nil unless Filesystem was given
+	Watches   *svc.WatchService    // nil unless Filesystem was given
+	Terminals *svc.TerminalService // nil unless Terminals was given
+
+	closeOnce sync.Once
+}
+
+// Build composes the host.
+func Build(opts Options) (*Built, error) {
+	if opts.CreateBackend == nil {
+		return nil, errors.New("compose: CreateBackend is required")
+	}
+	if opts.CreateSessionManager == nil {
+		opts.CreateSessionManager = pi.InMemoryStorage
+	}
+	logf := func(format string, args ...any) {
+		if opts.Log != nil {
+			opts.Log(format, args...)
+		}
+	}
+	h := host.New(host.Options{
+		ServerInfo: opts.ServerInfo, CompletionTriggerCharacters: []string{MentionTrigger},
+		Log: func(message string) { logf("%s", message) },
+	})
+	var models []pi.Model
+	if opts.Models != nil {
+		models = opts.Models()
+	}
+	h.InstallRootChannel([]ahptypes.AgentInfo{pi.BuildAgentInfo(models)})
+
+	deleteFile := opts.DeleteFile
+	if deleteFile == nil {
+		deleteFile = pi.FileDeleter
+	}
+	sessions := pi.NewServices(pi.ServicesOptions{
+		Host: h, SessionRoot: opts.SessionRoot, DefaultWorkingDirectory: opts.WorkingDirectory,
+		CreateBackend: opts.CreateBackend, CreateSessionManager: opts.CreateSessionManager,
+		DefaultSelection: opts.DefaultSelection, DeleteFile: deleteFile, WrapStore: opts.WrapStore, AdoptForeignTurns: opts.AdoptForeignTurns, Log: logf,
+	})
+	built := &Built{Host: h, Sessions: sessions}
+
+	caps := sessions.Capabilities()
+	caps.SessionConfig = pi.NewSessionConfigService(pi.SessionConfigOptions{
+		DefaultWorkingDirectory: opts.WorkingDirectory, ProjectTrustPolicy: opts.ProjectTrustPolicy, AgentDir: opts.AgentDir,
+	})
+	caps.Completions = pi.NewCompletionService(pi.CompletionServiceOptions{WorkingDirectoryFor: func(chat string) string {
+		if s, ok := sessions.Registry.GetByChat(chat); ok {
+			return s.WorkingDirectory
+		}
+		return ""
+	}})
+
+	if fs := opts.Filesystem; fs != nil {
+		if len(fs.Roots) == 0 && !fs.Unrestricted {
+			return nil, errors.New("compose: filesystem access needs roots, or Unrestricted set explicitly")
+		}
+		var roots []string
+		if !fs.Unrestricted {
+			roots = fs.Roots
+		}
+		policy, err := svc.NewPathPolicy(roots...)
+		if err != nil {
+			return nil, err
+		}
+		built.Resources = svc.NewResourceService(svc.ResourceOptions{Paths: policy})
+		built.Watches = svc.NewWatchService(h, svc.WatchOptions{Paths: policy, Log: func(m string) { logf("%s", m) }})
+		caps.Resources = built.Resources
+		caps.ResourceWatches = built.Watches
+	}
+	if t := opts.Terminals; t != nil {
+		built.Terminals = svc.NewTerminalService(h, svc.TerminalOptions{
+			DefaultWorkingDirectory: opts.WorkingDirectory, Shell: t.Shell, Spawn: t.Spawn, Log: func(m string) { logf("%s", m) },
+		})
+		caps.Terminals = built.Terminals
+	}
+	h.Serve(caps)
+	return built, nil
+}
+
+// Close shuts the optional services down: terminals are killed, watches released.
+func (b *Built) Close() {
+	b.closeOnce.Do(func() {
+		if b.Terminals != nil {
+			b.Terminals.Shutdown()
+		}
+		if b.Watches != nil {
+			<-b.Watches.Dispose()
+		}
+	})
+}

package/extensions/ahp/internal/compose/compose_test.go

@@ -0,0 +1,120 @@
+package compose
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	ahptypes "github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/mapper"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/pi"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+type idleBackend struct{}
+
+func (idleBackend) Subscribe(func(mapper.Event)) func()                  { return func() {} }
+func (idleBackend) Prompt(context.Context, string, []mapper.Image) error { return nil }
+func (idleBackend) Steer(context.Context, string, []mapper.Image) error  { return nil }
+func (idleBackend) Abort(context.Context) error                          { return nil }
+
+func TestComposition(t *testing.T) {
+	// Twin of upstream test/pi-host.test.ts. Upstream's resource read works without roots; here the
+	// unrestricted filesystem must be asked for explicitly (see PORT.md).
+	twin.Run(t, "pi-host", "wires product services through createPiHost", func(t *testing.T) {
+		workspace, _ := filepath.EvalSymlinks(t.TempDir())
+		sessionRoot := t.TempDir()
+		if err := os.WriteFile(filepath.Join(workspace, "notes.md"), []byte("# Notes\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		built, err := Build(Options{
+			ServerInfo: &ahptypes.Implementation{Name: "pi-ahp"}, WorkingDirectory: workspace, SessionRoot: sessionRoot,
+			CreateSessionManager: pi.PersistentStorage(sessionRoot),
+			CreateBackend:        func(*pi.LiveSession) (pi.Backend, error) { return idleBackend{}, nil },
+			DeleteFile:           func(string) (pi.SessionFileDeletionResult, error) { return pi.SessionFileDeletionResult{OK: true}, nil },
+			Filesystem:           &FilesystemOptions{Unrestricted: true},
+			Terminals:            &TerminalOptions{},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer built.Close()
+		c := testkit.Connect(t, built.Host)
+		defer c.Close()
+		init := c.Initialize("composition-client", map[string]any{"initialSubscriptions": []string{wire.RootChannel}})
+		if !reflect.DeepEqual(init.CompletionTriggerCharacters, []string{"@"}) {
+			t.Fatalf("trigger characters %v", init.CompletionTriggerCharacters)
+		}
+
+		var resource ahptypes.ResourceReadResult
+		c.Decode(c.Must("resourceRead", map[string]any{"channel": wire.RootChannel, "uri": wire.PathToFileURI(filepath.Join(workspace, "notes.md"))}), &resource)
+		if resource.Data != "# Notes\n" {
+			t.Fatalf("%+v", resource)
+		}
+
+		var config struct {
+			Schema struct{ Properties map[string]any }
+		}
+		c.Decode(c.Must("resolveSessionConfig", map[string]any{"channel": wire.RootChannel, "workingDirectory": wire.PathToFileURI(workspace)}), &config)
+		if config.Schema.Properties[pi.ProjectTrustKey] == nil {
+			t.Fatalf("no project trust property in %v", config.Schema.Properties)
+		}
+
+		id := "0a3c1e52-6b7d-4f3a-9d10-000000000001"
+		session, chat := wire.SessionURI(id), wire.ChatURI(id)
+		c.Must("createSession", map[string]any{"channel": session})
+		c.Must("subscribe", map[string]any{"channel": chat})
+		testkit.Eventually(t, "the composed session backend to become ready", func() bool {
+			s := built.Host.Store().Session(session)
+			return s != nil && s.Lifecycle == ahptypes.SessionLifecycleReady
+		})
+
+		var completions ahptypes.CompletionsResult
+		c.Decode(c.Must("completions", map[string]any{"channel": chat, "kind": "userMessage", "text": "see @not", "offset": 8}), &completions)
+		var inserted []string
+		for _, item := range completions.Items {
+			inserted = append(inserted, item.InsertText)
+		}
+		if !reflect.DeepEqual(inserted, []string{"@notes.md"}) {
+			raw, _ := json.Marshal(completions)
+			t.Fatalf("completions %s", raw)
+		}
+	})
+}
+
+func TestNothingIsExposedByDefault(t *testing.T) {
+	// Additions: fs and terminals are opt-in, and an unconfined filesystem must be explicit.
+	built, err := Build(Options{WorkingDirectory: t.TempDir(), CreateBackend: func(*pi.LiveSession) (pi.Backend, error) { return idleBackend{}, nil }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer built.Close()
+	if built.Resources != nil || built.Watches != nil || built.Terminals != nil {
+		t.Fatal("no filesystem or terminal service may exist without opt-in")
+	}
+	c := testkit.Connect(t, built.Host)
+	defer c.Close()
+	c.Initialize("nothing", nil)
+	c.ExpectError("resourceRead", map[string]any{"channel": wire.RootChannel, "uri": "file:///etc/hostname"}, wire.CodeMethodNotFound)
+	c.ExpectError("createTerminal", map[string]any{"channel": "ahp-terminal:/x", "claim": map[string]any{"kind": "client", "clientId": "nothing"}}, wire.CodeMethodNotFound)
+	c.ExpectError("createResourceWatch", map[string]any{"channel": wire.RootChannel, "uri": "file:///tmp"}, wire.CodeMethodNotFound)
+
+	if _, err := Build(Options{CreateBackend: func(*pi.LiveSession) (pi.Backend, error) { return idleBackend{}, nil }, Filesystem: &FilesystemOptions{}}); err == nil {
+		t.Fatal("a filesystem with no roots and no explicit Unrestricted must be refused")
+	}
+	confined, err := Build(Options{WorkingDirectory: t.TempDir(), CreateBackend: func(*pi.LiveSession) (pi.Backend, error) { return idleBackend{}, nil }, Filesystem: &FilesystemOptions{Roots: []string{t.TempDir()}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer confined.Close()
+	cc := testkit.Connect(t, confined.Host)
+	defer cc.Close()
+	cc.Initialize("confined", nil)
+	cc.ExpectError("resourceRead", map[string]any{"channel": wire.RootChannel, "uri": "file:///etc/hostname"}, wire.CodePermissionDenied)
+}

package/extensions/ahp/internal/gaps/gaps_test.go

@@ -0,0 +1,88 @@
+// Package gaps records the upstream (pi-ahp) test cases that have no runnable Go twin, each as a
+// named skipped twin with its reason. Nothing here is silent: the twin gate counts these, and
+// proof/PORT.md explains every family.
+package gaps
+
+import (
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+)
+
+func TestGapTunnel(t *testing.T) {
+	twin.Skip(t, "tunnel", "uses the shared discovery labels and port", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "keeps the identity label out of the display name", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "folds a name the way VS Code does", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "reports when the CLI is not installed", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "requires a logged-in account", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "reports account inspection failures", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "finds this host's first labelled tunnel", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "returns no tunnel for a successful empty listing", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "reports tunnel listing failures and malformed responses", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "creates a tunnel with identity, protocol, launcher, and display labels", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "rejects failed or malformed tunnel creation", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "renames a tunnel without disturbing reserved labels", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "reports a failed rename", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "creates port 31546 when a successful listing is empty", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "keeps an existing HTTP port", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "replaces an old HTTPS port with an HTTP port", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "does not discard port-specific access control while migrating", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "uses current port details when the protocol changes during inspection", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "rejects malformed port inspection output", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+	twin.Skip(t, "tunnel", "reports listing, inspection, deletion, and creation failures", "dev tunnel is not bundled: an owner decision (ACP, AHP and A2A are separate extensions, tunnel management stays outside this port)")
+}
+
+func TestGapPiReplay(t *testing.T) {
+	twin.Skip(t, "pi-replay", "plain-text", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "single-tool", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "parallel-tools", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-loop", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-error", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "abort", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "steering", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-edit", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-write", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-bash", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-ls", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-grep", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "tool-find", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "compaction", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+	twin.Skip(t, "pi-replay", "bash-long-output", "replays provider streams through a live Pi agent loop, which a Go extension cannot embed; the recorded-stream half is the mapper-fixtures twins and the live half is the layer-6 differential against a scripted provider")
+}
+
+func TestGapChangeset(t *testing.T) {
+	twin.Skip(t, "changeset", "keeps the latest commit separate from uncommitted work and refreshes it", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "limits changes to the session working-directory subtree", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "ignores ambient Git repository overrides", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "omits changesets when Git is unavailable", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "omits changesets outside Git workspaces", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "omits Latest Commit before the repository has a commit", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "resumes changeset updates when durable session deletion fails", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset", "hydrates the parent session when its changeset is subscribed directly", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+}
+
+func TestGapChangesetLifecycle(t *testing.T) {
+	twin.Skip(t, "changeset-lifecycle", "observes changes during the initial scan and rebuilds changed ignore rules", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset-lifecycle", "refreshes file changes while a turn is still active", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset-lifecycle", "does not recursively watch when ignored paths cannot be determined", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset-lifecycle", "publishes an explicit error when Git cannot compute the changeset", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset-lifecycle", "drains an in-flight scan before deleting its channel", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+}
+
+func TestGapChangesetURI(t *testing.T) {
+	twin.Skip(t, "changeset-uri", "builds stable static catalogue channels", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+	twin.Skip(t, "changeset-uri", "rejects channels the host did not advertise", "git changeset service not ported in this release (documented gap: no changeset channels are advertised, see PORT.md)")
+}
+
+func TestGapImageSession(t *testing.T) {
+	twin.Skip(t, "image-session", "passes and persists images while honouring preflight cancellation", "needs Pi's InProcessPiBackend with a faux model; the SDK adapter's image path is covered by its own adapter tests")
+}
+
+func TestGapLiveTurn(t *testing.T) {
+	twin.Skip(t, "live-turn", "live turn # SKIP needs a real model \u2014 set PI_AHP_LIVE_SETTINGS and PI_AHP_LIVE_AUTH", "upstream itself skips this case without a real model (PI_AHP_LIVE_SETTINGS and PI_AHP_LIVE_AUTH)")
+}
+
+func TestGapModelDiscovery(t *testing.T) {
+	twin.Skip(t, "model-discovery", "advertises extension models and uses pi's configured default", "needs an embedded Pi model registry with extension-provided models; the SDK adapter reads models through the PiG SDK and is covered by adapter tests")
+	twin.Skip(t, "model-discovery", "resolves stale and provider-qualified model selections safely", "needs an embedded Pi model registry with extension-provided models; the SDK adapter reads models through the PiG SDK and is covered by adapter tests")
+}