diff --git a/ogle/arch/arch.go b/arch/arch.go
similarity index 98%
rename from ogle/arch/arch.go
rename to arch/arch.go
index 4c76dc0..acd2ee9 100644
--- a/ogle/arch/arch.go
+++ b/arch/arch.go
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // Package arch contains architecture-specific definitions.
-package arch // import "golang.org/x/debug/ogle/arch"
+package arch // import "golang.org/x/debug/arch"
 
 import (
 	"encoding/binary"
diff --git a/ogle/cmd/ogleproxy/main.go b/cmd/debugproxy/main.go
similarity index 72%
rename from ogle/cmd/ogleproxy/main.go
rename to cmd/debugproxy/main.go
index 5459118..942790b 100644
--- a/ogle/cmd/ogleproxy/main.go
+++ b/cmd/debugproxy/main.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// The ogleproxy connects to the target binary and serves an RPC
-// interface to access and control it.
+// debugproxy connects to the target binary, and serves an RPC interface using
+// the types in server/protocol to access and control it.
 package main
 
 import (
@@ -13,7 +13,7 @@
 	"net/rpc"
 	"os"
 
-	"golang.org/x/debug/ogle/program/server"
+	"golang.org/x/debug/server"
 )
 
 var (
@@ -22,31 +22,29 @@
 
 func main() {
 	log.SetFlags(0)
-	log.SetPrefix("ogleproxy: ")
+	log.SetPrefix("debugproxy: ")
 	flag.Parse()
 	if *textFlag == "" {
-		fmt.Printf("OGLE BAD\n")
 		flag.Usage()
 		os.Exit(2)
 	}
 	s, err := server.New(*textFlag)
 	if err != nil {
-		fmt.Printf("OGLE BAD\n%s\n", err)
+		fmt.Printf("server.New: %v\n", err)
 		os.Exit(2)
 	}
 	err = rpc.Register(s)
 	if err != nil {
-		fmt.Printf("OGLE BAD\n%s\n", err)
+		fmt.Printf("rpc.Register: %v\n", err)
 		os.Exit(2)
 	}
-	fmt.Println("OGLE OK")
-	log.Print("start server")
-	// TODO: Usually done in a go.
+	fmt.Println("OK")
+	log.Print("starting server")
 	rpc.ServeConn(&rwc{
 		os.Stdin,
 		os.Stdout,
 	})
-	log.Print("finish server")
+	log.Print("server finished")
 }
 
 // rwc creates a single io.ReadWriteCloser from a read side and a write side.
diff --git a/ogle/doc/ptrace-nptl.txt b/doc/ptrace-nptl.txt
similarity index 100%
rename from ogle/doc/ptrace-nptl.txt
rename to doc/ptrace-nptl.txt
diff --git a/local/local.go b/local/local.go
new file mode 100644
index 0000000..e054249
--- /dev/null
+++ b/local/local.go
@@ -0,0 +1,193 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package local provides access to a local program.
+package local // import "golang.org/x/debug/local"
+
+import (
+	"golang.org/x/debug"
+	"golang.org/x/debug/server"
+	"golang.org/x/debug/server/protocol"
+)
+
+var _ debug.Program = (*Program)(nil)
+var _ debug.File = (*File)(nil)
+
+// Program implements the debug.Program interface.
+// Through that interface it provides access to a program being debugged.
+type Program struct {
+	s *server.Server
+}
+
+// New creates a new program from the specified file.
+// The program can then be started by the Run method.
+func New(textFile string) (*Program, error) {
+	s, err := server.New(textFile)
+	return &Program{s: s}, err
+}
+
+func (p *Program) Open(name string, mode string) (debug.File, error) {
+	req := protocol.OpenRequest{
+		Name: name,
+		Mode: mode,
+	}
+	var resp protocol.OpenResponse
+	err := p.s.Open(&req, &resp)
+	if err != nil {
+		return nil, err
+	}
+	f := &File{
+		prog: p,
+		fd:   resp.FD,
+	}
+	return f, nil
+}
+
+func (p *Program) Run(args ...string) (debug.Status, error) {
+	req := protocol.RunRequest{args}
+	var resp protocol.RunResponse
+	err := p.s.Run(&req, &resp)
+	if err != nil {
+		return debug.Status{}, err
+	}
+	return resp.Status, nil
+}
+
+func (p *Program) Stop() (debug.Status, error) {
+	panic("unimplemented")
+}
+
+func (p *Program) Resume() (debug.Status, error) {
+	req := protocol.ResumeRequest{}
+	var resp protocol.ResumeResponse
+	err := p.s.Resume(&req, &resp)
+	if err != nil {
+		return debug.Status{}, err
+	}
+	return resp.Status, nil
+}
+
+func (p *Program) Kill() (debug.Status, error) {
+	panic("unimplemented")
+}
+
+func (p *Program) Breakpoint(address uint64) ([]uint64, error) {
+	req := protocol.BreakpointRequest{
+		Address: address,
+	}
+	var resp protocol.BreakpointResponse
+	err := p.s.Breakpoint(&req, &resp)
+	return resp.PCs, err
+}
+
+func (p *Program) BreakpointAtFunction(name string) ([]uint64, error) {
+	req := protocol.BreakpointAtFunctionRequest{
+		Function: name,
+	}
+	var resp protocol.BreakpointResponse
+	err := p.s.BreakpointAtFunction(&req, &resp)
+	return resp.PCs, err
+}
+
+func (p *Program) BreakpointAtLine(file string, line uint64) ([]uint64, error) {
+	req := protocol.BreakpointAtLineRequest{
+		File: file,
+		Line: line,
+	}
+	var resp protocol.BreakpointResponse
+	err := p.s.BreakpointAtLine(&req, &resp)
+	return resp.PCs, err
+}
+
+func (p *Program) DeleteBreakpoints(pcs []uint64) error {
+	req := protocol.DeleteBreakpointsRequest{PCs: pcs}
+	var resp protocol.DeleteBreakpointsResponse
+	return p.s.DeleteBreakpoints(&req, &resp)
+}
+
+func (p *Program) Eval(expr string) ([]string, error) {
+	req := protocol.EvalRequest{
+		Expr: expr,
+	}
+	var resp protocol.EvalResponse
+	err := p.s.Eval(&req, &resp)
+	return resp.Result, err
+}
+
+func (p *Program) Evaluate(e string) (debug.Value, error) {
+	req := protocol.EvaluateRequest{
+		Expression: e,
+	}
+	var resp protocol.EvaluateResponse
+	err := p.s.Evaluate(&req, &resp)
+	return resp.Result, err
+}
+
+func (p *Program) Frames(count int) ([]debug.Frame, error) {
+	req := protocol.FramesRequest{
+		Count: count,
+	}
+	var resp protocol.FramesResponse
+	err := p.s.Frames(&req, &resp)
+	return resp.Frames, err
+}
+
+func (p *Program) Goroutines() ([]*debug.Goroutine, error) {
+	req := protocol.GoroutinesRequest{}
+	var resp protocol.GoroutinesResponse
+	err := p.s.Goroutines(&req, &resp)
+	return resp.Goroutines, err
+}
+
+func (p *Program) VarByName(name string) (debug.Var, error) {
+	req := protocol.VarByNameRequest{Name: name}
+	var resp protocol.VarByNameResponse
+	err := p.s.VarByName(&req, &resp)
+	return resp.Var, err
+}
+
+func (p *Program) Value(v debug.Var) (debug.Value, error) {
+	req := protocol.ValueRequest{Var: v}
+	var resp protocol.ValueResponse
+	err := p.s.Value(&req, &resp)
+	return resp.Value, err
+}
+
+func (p *Program) MapElement(m debug.Map, index uint64) (debug.Var, debug.Var, error) {
+	req := protocol.MapElementRequest{Map: m, Index: index}
+	var resp protocol.MapElementResponse
+	err := p.s.MapElement(&req, &resp)
+	return resp.Key, resp.Value, err
+}
+
+// File implements the debug.File interface, providing access
+// to file-like resources associated with the target program.
+type File struct {
+	prog *Program // The Program associated with the file.
+	fd   int      // File descriptor.
+}
+
+func (f *File) ReadAt(p []byte, offset int64) (int, error) {
+	req := protocol.ReadAtRequest{
+		FD:     f.fd,
+		Len:    len(p),
+		Offset: offset,
+	}
+	var resp protocol.ReadAtResponse
+	err := f.prog.s.ReadAt(&req, &resp)
+	return copy(p, resp.Data), err
+}
+
+func (f *File) WriteAt(p []byte, offset int64) (int, error) {
+	panic("unimplemented")
+}
+
+func (f *File) Close() error {
+	req := protocol.CloseRequest{
+		FD: f.fd,
+	}
+	var resp protocol.CloseResponse
+	err := f.prog.s.Close(&req, &resp)
+	return err
+}
diff --git a/ogle/demo/ptrace-linux-amd64/main.go b/ogle/demo/ptrace-linux-amd64/main.go
deleted file mode 100644
index c90c534..0000000
--- a/ogle/demo/ptrace-linux-amd64/main.go
+++ /dev/null
@@ -1,270 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This program is a standalone demo that demonstrates a Go tracer program
-// (this program) forking, executing and inserting breakpoints into a (multi-
-// threaded) Go tracee program. It logs all syscall.Wait4 results, and reading
-// those logs, as well as ../../doc/ptrace-nptl.txt, should help understand how
-// the (more complicated) golang.org/x/debug/ogle/program/server package works.
-//
-// Only tested on linux/amd64.
-package main
-
-// TODO: other threads are not stopped when one tracee thread hits a breakpoint.
-// Thus, other threads could racily miss a breakpoint when they concurrently
-// execute code where the trap should be, in between lifting and re-setting the
-// trap.
-//
-// One option is to simply accept this behavior as is. Another option, "all-
-// stop", is to stop all other threads when one traps. A third option, "non-
-// stop", is to not lift the trap and not stop other threads, but to simulate
-// the original instruction when single-stepping: the "Non-stop Multi-Threaded
-// Debugging in GDB" paper calls this "displaced stepping". "Non-stop" is less
-// intrusive than "all-stop" (e.g. network I/O can still happen while at a
-// breakpoint), but it involves complicated, architecture-specific code.
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"runtime"
-	"syscall"
-	"time"
-
-	"golang.org/x/debug/dwarf"
-	"golang.org/x/debug/elf"
-	"golang.org/x/debug/macho"
-)
-
-const (
-	exeFilename = "tracee/tracee"
-
-	// TODO: don't be amd64-specific.
-	breakpointInstr    = 0xcc
-	breakpointInstrLen = 1
-)
-
-type breakpoint struct {
-	pc        uint64
-	origInstr byte // TODO: don't be amd64-specific.
-}
-
-func main() {
-	go run()
-	time.Sleep(2 * time.Second)
-}
-
-func run() {
-	// If the debugger itself is multi-threaded, ptrace calls must come from
-	// the same thread that originally attached to the remote thread.
-	runtime.LockOSThread()
-
-	f, err := os.Open(exeFilename)
-	if err != nil {
-		log.Printf(`%q not found. Did you run "go build ." in that directory?`, exeFilename)
-		log.Fatalf("Open: %v", err)
-	}
-	defer f.Close()
-	dwarfData, err := loadDwarfData(f)
-	if err != nil {
-		log.Fatalf("loadDwarfData: %v", err)
-	}
-
-	proc, err := os.StartProcess(exeFilename, []string{exeFilename}, &os.ProcAttr{
-		Files: []*os.File{
-			os.Stdin,
-			os.Stdout,
-			os.Stderr,
-		},
-		Sys: &syscall.SysProcAttr{
-			Ptrace:    true,
-			Pdeathsig: syscall.SIGKILL,
-		},
-	})
-	if err != nil {
-		log.Fatalf("StartProcess: %v", err)
-	}
-
-	fmt.Printf("\tproc.Pid=%d\n", proc.Pid)
-
-	_, status, err := wait(proc.Pid)
-	if err != nil {
-		log.Fatalf("wait: %v", err)
-	}
-	if status != 0x00057f { // 0x05=SIGTRAP, 0x7f=stopped.
-		log.Fatalf("status: got %#x, want %#x", status, 0x57f)
-	}
-	err = syscall.PtraceSetOptions(proc.Pid, syscall.PTRACE_O_TRACECLONE|syscall.PTRACE_O_TRACEEXIT)
-	if err != nil {
-		log.Fatalf("PtraceSetOptions: %v", err)
-	}
-
-	addr, err := lookupSym(dwarfData, "fmt.Printf")
-	if err != nil {
-		log.Fatalf("lookupSym: %v", err)
-	}
-	fmt.Printf("\tfmt.Printf=%#x\n", addr)
-
-	var buf [1]byte
-	if err := peek(proc.Pid, addr, buf[:1]); err != nil {
-		log.Fatalf("peek: %v", err)
-	}
-	breakpoints := map[uint64]breakpoint{
-		addr: {pc: addr, origInstr: buf[0]},
-	}
-	buf[0] = breakpointInstr
-	if err := poke(proc.Pid, addr, buf[:1]); err != nil {
-		log.Fatalf("poke: %v", err)
-	}
-
-	err = syscall.PtraceCont(proc.Pid, 0)
-	if err != nil {
-		log.Fatalf("PtraceCont: %v", err)
-	}
-
-	for {
-		pid, status, err := wait(-1)
-		if err != nil {
-			log.Fatalf("wait: %v", err)
-		}
-
-		switch status {
-		case 0x00057f: // 0x05=SIGTRAP, 0x7f=stopped.
-			regs := syscall.PtraceRegs{}
-			if err := syscall.PtraceGetRegs(pid, &regs); err != nil {
-				log.Fatalf("PtraceGetRegs: %v", err)
-			}
-			regs.Rip -= breakpointInstrLen
-			if err := syscall.PtraceSetRegs(pid, &regs); err != nil {
-				log.Fatalf("PtraceSetRegs: %v", err)
-			}
-			bp, ok := breakpoints[regs.Rip]
-			if !ok {
-				log.Fatalf("no breakpoint for address %#x\n", regs.Rip)
-			}
-			buf[0] = bp.origInstr
-			if err := poke(pid, addr, buf[:1]); err != nil {
-				log.Fatalf("poke: %v", err)
-			}
-			fmt.Printf("\thit breakpoint at %#x, pid=%5d\n", regs.Rip, pid)
-			if err := syscall.PtraceSingleStep(pid); err != nil {
-				log.Fatalf("PtraceSingleStep: %v", err)
-			}
-			_, status, err := wait(pid)
-			if err != nil {
-				log.Fatalf("wait: %v", err)
-			}
-			if status != 0x00057f {
-				log.Fatalf("PtraceSingleStep: unexpected status %#x\n", status)
-			}
-			buf[0] = breakpointInstr
-			if err := poke(pid, addr, buf[:1]); err != nil {
-				log.Fatalf("poke: %v", err)
-			}
-
-		case 0x00137f: // 0x13=SIGSTOP, 0x7f=stopped.
-			// No-op.
-
-		case 0x03057f: // 0x05=SIGTRAP, 0x7f=stopped, 0x03=PTRACE_EVENT_CLONE.
-			msg, err := syscall.PtraceGetEventMsg(pid)
-			if err != nil {
-				log.Fatalf("PtraceGetEventMsg: %v", err)
-			}
-			fmt.Printf("\tclone: new pid=%d\n", msg)
-
-		default:
-			log.Fatalf("unexpected status %#x\n", status)
-		}
-
-		err = syscall.PtraceCont(pid, 0)
-		if err != nil {
-			log.Fatalf("PtraceCont: %v", err)
-		}
-	}
-}
-
-func wait(pid int) (wpid int, status syscall.WaitStatus, err error) {
-	wpid, err = syscall.Wait4(pid, &status, syscall.WALL, nil)
-	if err != nil {
-		return 0, 0, err
-	}
-	fmt.Printf("\t\twait: wpid=%5d, status=0x%06x\n", wpid, status)
-	return wpid, status, nil
-}
-
-func peek(pid int, addr uint64, data []byte) error {
-	n, err := syscall.PtracePeekText(pid, uintptr(addr), data)
-	if err != nil {
-		return err
-	}
-	if n != len(data) {
-		return fmt.Errorf("peek: got %d bytes, want %d", len(data))
-	}
-	return nil
-}
-
-func poke(pid int, addr uint64, data []byte) error {
-	n, err := syscall.PtracePokeText(pid, uintptr(addr), data)
-	if err != nil {
-		return err
-	}
-	if n != len(data) {
-		return fmt.Errorf("poke: got %d bytes, want %d", len(data))
-	}
-	return nil
-}
-
-func lookupSym(dwarfData *dwarf.Data, name string) (uint64, error) {
-	r := dwarfData.Reader()
-	for {
-		entry, err := r.Next()
-		if err != nil {
-			return 0, err
-		}
-		if entry == nil {
-			// TODO: why don't we get an error here.
-			break
-		}
-		if entry.Tag != dwarf.TagSubprogram {
-			continue
-		}
-		nameAttr := lookupAttr(entry, dwarf.AttrName)
-		if nameAttr == nil {
-			// TODO: this shouldn't be possible.
-			continue
-		}
-		if nameAttr.(string) != name {
-			continue
-		}
-		addrAttr := lookupAttr(entry, dwarf.AttrLowpc)
-		if addrAttr == nil {
-			return 0, fmt.Errorf("symbol %q has no LowPC attribute", name)
-		}
-		addr, ok := addrAttr.(uint64)
-		if !ok {
-			return 0, fmt.Errorf("symbol %q has non-uint64 LowPC attribute", name)
-		}
-		return addr, nil
-	}
-	return 0, fmt.Errorf("symbol %q not found", name)
-}
-
-func lookupAttr(e *dwarf.Entry, a dwarf.Attr) interface{} {
-	for _, f := range e.Field {
-		if f.Attr == a {
-			return f.Val
-		}
-	}
-	return nil
-}
-
-func loadDwarfData(f *os.File) (*dwarf.Data, error) {
-	if obj, err := elf.NewFile(f); err == nil {
-		return obj.DWARF()
-	}
-	if obj, err := macho.NewFile(f); err == nil {
-		return obj.DWARF()
-	}
-	return nil, fmt.Errorf("unrecognized binary format")
-}
diff --git a/ogle/demo/ptrace-linux-amd64/tracee/main.go b/ogle/demo/ptrace-linux-amd64/tracee/main.go
deleted file mode 100644
index 042e4f7..0000000
--- a/ogle/demo/ptrace-linux-amd64/tracee/main.go
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This program prints to stdout from multiple goroutines multiplexed onto
-// multiple threads. It is used as the tracee program by the debugger (tracer)
-// program in the parent directory.
-package main
-
-import (
-	"fmt"
-	"runtime"
-	"syscall"
-	"time"
-)
-
-// ansiColor is whether to display ANSI color codes in the program's output.
-// This distinguishes this program's output (the tracee's) from the debugger
-// program's output (the tracer's).
-const ansiColor = false
-
-var prefix, suffix string
-
-func run(base int, sleep time.Duration, lockOSThread bool) {
-	if lockOSThread {
-		runtime.LockOSThread()
-	}
-	for i := 0; ; i++ {
-		fmt.Printf("%sx=%5d tid=%d%s\n", prefix, base+i, syscall.Gettid(), suffix)
-		time.Sleep(sleep)
-	}
-}
-
-func main() {
-	if ansiColor {
-		prefix, suffix = "\x1b[36m", "\x1b[0m"
-	}
-	go run(0, 300*time.Millisecond, false)
-	go run(100, 500*time.Millisecond, false)
-	go run(10000, 700*time.Millisecond, true)
-	time.Sleep(5 * time.Second)
-}
diff --git a/ogle/probe/addr_test.go b/ogle/probe/addr_test.go
deleted file mode 100644
index 48ff2ac..0000000
--- a/ogle/probe/addr_test.go
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package probe
-
-import (
-	"reflect"
-	"testing"
-)
-
-// Defined in assembler.
-func base() uintptr
-func etext() uintptr
-func edata() uintptr
-func end() uintptr
-
-var dataItem = 3
-var bssItem [100]int
-
-// addr turns an arbitrary address into a uintptr.
-func addr(p interface{}) uintptr {
-	v := reflect.ValueOf(p)
-	switch v.Kind() {
-	case reflect.Ptr:
-		return v.Elem().UnsafeAddr()
-	default:
-		// TODO: how do we find the address of a text symbol?
-		panic("unknown type " + v.Type().String())
-	}
-}
-
-func TestGoodReadAddresses(t *testing.T) {
-	addrs := []uintptr{
-		base(),
-		addr(&t),        // On the stack.
-		addr(&dataItem), // In data.
-		addr(&bssItem),  // In bss.
-	}
-	for _, a := range addrs {
-		if !validRead(a, 1) {
-			t.Errorf("%#x is invalid; should be valid", a)
-		}
-	}
-}
-
-func TestBadReadAddresses(t *testing.T) {
-	addrs := []uintptr{
-		0,
-		base()/2 - 1, // Pull well down below; the Mac only unmaps up to 0x1000.
-		^uintptr(0),
-	}
-	for _, a := range addrs {
-		if validRead(a, 1) {
-			t.Errorf("%#x is valid; should be invalid", a)
-		}
-	}
-}
-
-func TestGoodWriteAddresses(t *testing.T) {
-	addrs := []uintptr{
-		addr(&t),        // On the stack.
-		addr(&dataItem), // In data.
-		addr(&bssItem),  // In bss.
-	}
-	for _, a := range addrs {
-		if !validWrite(a, 1) {
-			t.Errorf("%#x is invalid; should be valid", a)
-		}
-	}
-}
-
-func TestBadWriteAddresses(t *testing.T) {
-	addrs := []uintptr{
-		0,
-		base(), // In the text segment.
-		base() - 1,
-		^uintptr(0),
-	}
-	for _, a := range addrs {
-		if validWrite(a, 1) {
-			t.Errorf("%#x is valid; should be invalid", a)
-		}
-	}
-}
diff --git a/ogle/probe/net.go b/ogle/probe/net.go
deleted file mode 100644
index 87ebe98..0000000
--- a/ogle/probe/net.go
+++ /dev/null
@@ -1,286 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// TODO: Document the protocol once it settles.
-
-package probe
-
-import (
-	"errors"
-	"io" // Used only for the definitions of the various interfaces and errors.
-	"net"
-
-	"golang.org/x/debug/ogle/socket"
-)
-
-var (
-	tracing   = false
-	listening = make(chan struct{})
-)
-
-// init starts a listener and leaves it in the background waiting for connections.
-func init() {
-	go demon()
-}
-
-// demon answers consecutive connection requests and starts a server to manage each one.
-// The server runs in the same goroutine as the demon, so a new connection cannot be
-// established until the previous one is completed.
-func demon() {
-	listener, err := socket.Listen()
-	close(listening)
-	if err != nil {
-		trace("listen:", err)
-		return
-	}
-	trace("listening")
-	for {
-		conn, err := listener.Accept()
-		if err != nil {
-			trace("accept", err)
-			continue
-		}
-		trace("accepted a connection")
-		serve(conn)
-		conn.Close()
-	}
-}
-
-// stringer is the same as fmt.Stringer. We redefine it here to avoid pulling in fmt.
-type stringer interface {
-	String() string
-}
-
-func printHex(b byte) {
-	const hex = "0123456789ABCDEF"
-	b1, b0 := b>>4&0xF, b&0xF
-	print(hex[b1:b1+1], hex[b0:b0+1])
-}
-
-// trace is a simple version of println that is enabled by the tracing boolean.
-func trace(args ...interface{}) {
-	if !tracing {
-		return
-	}
-	print("ogle demon: ")
-	for i, arg := range args {
-		if i > 0 {
-			print(" ")
-		}
-		// A little help. Built-in print isn't very capable.
-		switch arg := arg.(type) {
-		case stringer:
-			print(arg.String())
-		case error:
-			print(arg.Error())
-		case []byte:
-			print("[")
-			for i := range arg {
-				if i > 0 {
-					print(" ")
-				}
-				printHex(arg[i])
-			}
-			print("]")
-		case int:
-			print(arg)
-		case string:
-			print(arg)
-		case uintptr:
-			print("0x")
-			for i := ptrSize - 1; i >= 0; i-- {
-				printHex(byte(arg >> uint(8*i)))
-			}
-		default:
-			print(arg)
-		}
-	}
-	print("\n")
-}
-
-func serve(conn net.Conn) {
-	const (
-		bufSize = 1 << 16
-	)
-	var buf [bufSize]byte
-	network := &pipe{
-		rw: conn,
-	}
-	for {
-		// One message per loop.
-		n, err := network.Read(buf[:1])
-		if n != 1 || err != nil {
-			return
-		}
-		switch buf[0] {
-		case 'r':
-			// Read: ['r', address, size] => [0, size, size bytes]
-			u, err := network.readUintptr()
-			if err != nil {
-				return
-			}
-			n, err := network.readInt()
-			if err != nil {
-				return
-			}
-			if !validRead(u, n) {
-				trace("read", err)
-				network.error("invalid read address")
-				continue
-			}
-			network.sendReadResponse(u, n)
-		default:
-			// TODO: shut down connection?
-			trace("unknown message type:", buf[0])
-		}
-	}
-}
-
-// pipe is a buffered network connection (actually just a reader/writer) that
-// implements Read and ReadByte as well as readFull.
-// It also has support routines to make it easier to read and write
-// network messages.
-type pipe struct {
-	rw      io.ReadWriter
-	pos     int
-	end     int
-	oneByte [1]byte
-	buf     [4096]byte
-}
-
-// readFull fills the argument slice with data from the wire. If it cannot fill the
-// slice, it returns an error.
-// TODO: unused for now; write will need it.
-func (p *pipe) readFull(buf []byte) error {
-	for len(buf) > 0 {
-		n, err := p.rw.Read(buf)
-		if n == len(buf) {
-			return nil
-		}
-		if err != nil {
-			if err == io.EOF {
-				err = io.ErrUnexpectedEOF
-			}
-			return err
-		}
-		if n == 0 {
-			return io.EOF
-		}
-		buf = buf[n:]
-	}
-	return nil
-}
-
-// Read satisfies io.Reader.
-func (p *pipe) Read(buf []byte) (int, error) {
-	n := len(buf)
-	if p.end == p.pos {
-		p.pos = 0
-		// Read from network
-		var err error
-		p.end, err = p.rw.Read(p.buf[:])
-		if err != nil {
-			trace("read:", err)
-			return p.end, err
-		}
-		if p.end == 0 {
-			trace("read: eof")
-			return p.end, io.EOF
-		}
-	}
-	if n > p.end-p.pos {
-		n = p.end - p.pos
-	}
-	copy(buf, p.buf[p.pos:p.pos+n])
-	p.pos += n
-	return n, nil
-}
-
-// ReadByte satisfies io.ByteReader.
-func (p *pipe) ReadByte() (byte, error) {
-	_, err := p.Read(p.oneByte[:])
-	return p.oneByte[0], err
-}
-
-// readUintptr reads a varint-encoded uinptr value from the connection.
-func (p *pipe) readUintptr() (uintptr, error) {
-	u, err := readUvarint(p)
-	if err != nil {
-		trace("read uintptr:", err)
-		return 0, err
-	}
-	if u > uint64(^uintptr(0)) {
-		trace("read uintptr: overflow")
-		return 0, err
-	}
-	return uintptr(u), nil
-}
-
-var intOverflow = errors.New("ogle probe: varint overflows int")
-
-// readInt reads an varint-encoded int value from the connection.
-// The transported value is always a uint64; this routine
-// verifies that it fits in an int.
-func (p *pipe) readInt() (int, error) {
-	u, err := readUvarint(p)
-	if err != nil {
-		trace("read int:", err)
-		return 0, err
-	}
-	// Does it fit in an int?
-	if u > maxInt {
-		trace("int overflow")
-		return 0, intOverflow
-	}
-	return int(u), nil
-}
-
-// error writes an error message to the connection.
-// The format is [size, size bytes].
-func (p *pipe) error(msg string) {
-	// A zero-length message is problematic. It should never arise, but be safe.
-	if len(msg) == 0 {
-		msg = "undefined error"
-	}
-	// Truncate if necessary. Extremely unlikely.
-	if len(msg) > len(p.buf)-maxVarintLen64 {
-		msg = msg[:len(p.buf)-maxVarintLen64]
-	}
-	n := putUvarint(p.buf[:], uint64(len(msg)))
-	n += copy(p.buf[n:], msg)
-	_, err := p.rw.Write(p.buf[:n])
-	if err != nil {
-		trace("write:", err)
-		// TODO: shut down connection?
-	}
-}
-
-// sendReadResponse sends a read response to the connection.
-// The format is [0, size, size bytes].
-func (p *pipe) sendReadResponse(addr uintptr, size int) {
-	trace("sendRead:", addr, size)
-	m := 0
-	m += putUvarint(p.buf[m:], 0)            // No error.
-	m += putUvarint(p.buf[m:], uint64(size)) // Number of bytes to follow.
-	for m > 0 || size > 0 {
-		n := len(p.buf) - m
-		if n > size {
-			n = size
-		}
-		if !read(addr, p.buf[m:m+n]) {
-			trace("copy error")
-			// TODO: shut down connection?
-			// TODO: for now, continue delivering data. We said we would.
-		}
-		_, err := p.rw.Write(p.buf[:m+n])
-		if err != nil {
-			trace("write:", err)
-			// TODO: shut down connection?
-		}
-		addr += uintptr(n)
-		size -= n
-		// Next time we can use the whole buffer.
-		m = 0
-	}
-}
diff --git a/ogle/probe/net_test.go b/ogle/probe/net_test.go
deleted file mode 100644
index c9d599d..0000000
--- a/ogle/probe/net_test.go
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package probe
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"os"
-	"testing"
-	"unsafe"
-
-	"golang.org/x/debug/ogle/socket"
-)
-
-// traceThisFunction turns on tracing and returns a function to turn it off.
-// It is intended for use as "defer traceThisFunction()()".
-func traceThisFunction() func() {
-	// TODO: This should be done atomically to guarantee the probe can see the update.
-	tracing = true
-	return func() {
-		tracing = false
-	}
-}
-
-type Conn struct {
-	conn   net.Conn
-	input  *bufio.Reader
-	output *bufio.Writer
-}
-
-func (c *Conn) close() {
-	c.output.Flush()
-	c.conn.Close()
-}
-
-// newConn makes a connection.
-func newConn(t *testing.T) *Conn {
-	// defer traceThisFunction()()
-	<-listening
-	conn, err := socket.Dial(os.Getuid(), os.Getpid())
-	if err != nil {
-		t.Fatal(err)
-	}
-	return &Conn{
-		conn:   conn,
-		input:  bufio.NewReader(conn),
-		output: bufio.NewWriter(conn),
-	}
-}
-
-// bytesToUint64 returns the uint64 stored in the 8 bytes of buf.
-func bytesToUint64(buf []byte) uint64 {
-	// We're using same machine here, so byte order is the same.
-	// We can just fetch it, but on some architectures it
-	// must be aligned so copy first.
-	var tmp [8]byte
-	copy(tmp[:], buf)
-	return *(*uint64)(unsafe.Pointer(&tmp[0]))
-}
-
-// Test that we get an error back for a request to read an illegal address.
-func TestReadBadAddress(t *testing.T) {
-	//defer traceThisFunction()()
-
-	conn := newConn(t)
-	defer conn.close()
-
-	// Read the elements in pseudo-random order.
-	var tmp [100]byte
-	// Request a read of a bad address.
-	conn.output.WriteByte('r')
-	// Address.
-	n := putUvarint(tmp[:], 0)
-	conn.output.Write(tmp[:n])
-	// Length. Any length will do.
-	n = putUvarint(tmp[:], 8)
-	conn.output.Write(tmp[:n])
-	// Send it.
-	err := conn.output.Flush()
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Read result.
-	// We expect an initial non-zero value, the number of bytes of the error message.
-	u, err := readUvarint(conn.input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if u == 0 {
-		t.Fatalf("expected error return; got none")
-	}
-	// We expect a particular error.
-	const expect = "invalid read address"
-	if u != uint64(len(expect)) {
-		t.Fatalf("got %d bytes; expected %d", u, len(expect))
-	}
-	_, err = io.ReadFull(conn.input, tmp[:u])
-	if err != nil {
-		t.Fatal(err)
-	}
-	msg := string(tmp[:u])
-	if msg != expect {
-		t.Fatalf("got %q; expected %q", msg, expect)
-	}
-}
-
-// Test that we can read some data from the address space on the other side of the connection.
-func TestReadUint64(t *testing.T) {
-	//defer traceThisFunction()()
-
-	conn := newConn(t)
-	defer conn.close()
-
-	// Some data to send over the wire.
-	data := make([]uint64, 10)
-	for i := range data {
-		data[i] = 0x1234567887654321 + 12345*uint64(i)
-	}
-	// TODO: To be righteous we should put a memory barrier here.
-
-	// Read the elements in pseudo-random order.
-	var tmp [100]byte
-	which := 0
-	for i := 0; i < 100; i++ {
-		which = (which + 7) % len(data)
-		// Request a read of data[which].
-		conn.output.WriteByte('r')
-		// Address.
-		n := putUvarint(tmp[:], uint64(addr(&data[which])))
-		conn.output.Write(tmp[:n])
-		// Length
-		n = putUvarint(tmp[:], 8)
-		conn.output.Write(tmp[:n])
-		// Send it.
-		err := conn.output.Flush()
-		if err != nil {
-			t.Fatal(err)
-		}
-		// Read result.
-		// We expect 10 bytes: the initial zero, followed by 8 (the count), followed by 8 bytes of data.
-		u, err := readUvarint(conn.input)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if u != 0 {
-			t.Fatalf("expected leading zero byte; got %#x\n", u)
-		}
-		// N bytes of data.
-		u, err = readUvarint(conn.input)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if u != 8 {
-			t.Fatalf("got %d bytes of data; expected 8", u)
-		}
-		_, err = io.ReadFull(conn.input, tmp[:u])
-		if err != nil {
-			t.Fatal(err)
-		}
-		u = bytesToUint64(tmp[:u])
-		if u != data[which] {
-			t.Fatalf("got %#x; expected %#x", u, data[which])
-		}
-	}
-}
-
-// Test that we can read an array bigger than the pipe's buffer size.
-func TestBigRead(t *testing.T) {
-	// defer traceThisFunction()()
-
-	conn := newConn(t)
-	defer conn.close()
-
-	// A big slice.
-	data := make([]byte, 3*len(pipe{}.buf))
-	noise := 17
-	for i := range data {
-		data[i] = byte(noise)
-		noise += 23
-	}
-	// TODO: To be righteous we should put a memory barrier here.
-
-	// Read the elements in one big call.
-	tmp := make([]byte, len(data))
-	conn.output.WriteByte('r')
-	// Address.
-	n := putUvarint(tmp[:], uint64(addr(&data[0])))
-	conn.output.Write(tmp[:n])
-	// Length.
-	n = putUvarint(tmp[:], uint64(len(data)))
-	conn.output.Write(tmp[:n])
-	// Send it.
-	err := conn.output.Flush()
-	if err != nil {
-		t.Fatal(err)
-	}
-	// Read result.
-	// We expect the full data back.
-	u, err := readUvarint(conn.input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if u != 0 {
-		t.Fatalf("expected leading zero byte; got %#x\n", u)
-	}
-	// N bytes of data.
-	u, err = readUvarint(conn.input)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if u != uint64(len(data)) {
-		t.Fatalf("got %d bytes of data; expected 8", u)
-	}
-	_, err = io.ReadFull(conn.input, tmp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, c := range data {
-		if tmp[i] != c {
-			t.Fatalf("at offset %d expected %#x; got %#x", i, c, tmp[i])
-		}
-	}
-}
-
-// TestCollectGarbage doesn't actually test anything, but it does collect any
-// garbage sockets that are no longer used. It is a courtesy for computers that
-// run this test suite often.
-func TestCollectGarbage(t *testing.T) {
-	socket.CollectGarbage()
-}
diff --git a/ogle/probe/probe.go b/ogle/probe/probe.go
deleted file mode 100644
index 9db1f81..0000000
--- a/ogle/probe/probe.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package probe is imported by programs to provide (possibly remote)
-// access to a separate debugger program.
-package probe // import "golang.org/x/debug/ogle/probe"
-
-import (
-	"runtime/debug"
-	"unsafe"
-)
-
-// catchFault is used by the read and write routines to turn a panic into an error return.
-func catchFault(ok *bool) {
-	if e := recover(); e != nil {
-		*ok = false
-	}
-}
-
-// validRead reports whether a read of the specified size can be done at address p.
-// TODO: It does this by actually doing the read and seeing if it succeeds. Do better.
-func validRead(p uintptr, size int) (ok bool) {
-	// Check for negative size and for (p + size) overflow.
-	if size < 0 || uint64(^uintptr(0)-p) < uint64(size) {
-		return false
-	}
-	defer catchFault(&ok)
-	defer debug.SetPanicOnFault(debug.SetPanicOnFault(true))
-	ep := p + uintptr(size)
-	var b byte
-	for p < ep {
-		b = *(*byte)(unsafe.Pointer(p))
-		_ = b
-		p++
-	}
-	return true
-}
-
-// validWrite reports whether a write of the specified size can be done at address p.
-// TODO: It does this by actually doing a write and seeing if it succeeds. Do better.
-func validWrite(p uintptr, size int) (ok bool) {
-	// Check for negative size and for (p + size) overflow.
-	if size < 0 || uint64(^uintptr(0)-p) < uint64(size) {
-		return false
-	}
-	defer catchFault(&ok)
-	defer debug.SetPanicOnFault(debug.SetPanicOnFault(true))
-	ep := p + uintptr(size)
-	for p < ep {
-		*(*byte)(unsafe.Pointer(p)) = *(*byte)(unsafe.Pointer(p))
-		p++
-	}
-	return true
-}
-
-// read copies into the argument buffer the contents of memory starting at address p.
-// Its boolean return tells whether it succeeded. If it fails, no bytes were copied.
-func read(p uintptr, buf []byte) (ok bool) {
-	defer catchFault(&ok)
-	defer debug.SetPanicOnFault(debug.SetPanicOnFault(true))
-	for i := range buf {
-		buf[i] = *(*byte)(unsafe.Pointer(p))
-		p++
-	}
-	return true
-}
-
-// write copies the argument buffer to memory starting at address p.
-// Its boolean return tells whether it succeeded. If it fails, no bytes were copied.
-func write(p uintptr, buf []byte) (ok bool) {
-	defer catchFault(&ok)
-	defer debug.SetPanicOnFault(debug.SetPanicOnFault(true))
-	for i := range buf {
-		*(*byte)(unsafe.Pointer(p)) = buf[i]
-		p++
-	}
-	return true
-}
diff --git a/ogle/probe/probe_darwin_amd64.s b/ogle/probe/probe_darwin_amd64.s
deleted file mode 100644
index 90ec8cc..0000000
--- a/ogle/probe/probe_darwin_amd64.s
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// TODO #include "../../cmd/ld/textflag.h"
-
-#define NOSPLIT 4
-
-// Functions that return details about our address space.
-// They use the C-defined symbols like edata and also know
-// a little about the heap and memory layout.
-
-// From the linker. Well-known but might change.
-// TODO: Is there a better way to know this?
-#define	INITTEXT 0x2000
-
-// base of the address space.
-TEXT ·base(SB), NOSPLIT, $0
-	MOVQ	$INITTEXT, ret+0(FP)
-	RET
-
-// end of the text segment.
-TEXT ·etext(SB), NOSPLIT, $0
-	LEAQ	etext+0(SB), BX
-	MOVQ	BX, ret+0(FP)
-	RET
-
-// end of the data segment.
-TEXT ·edata(SB), NOSPLIT, $0
-	LEAQ	edata+0(SB), BX
-	MOVQ	BX, ret+0(FP)
-	RET
-
-// end of the pre-defined address space.
-TEXT ·end(SB), NOSPLIT, $0
-	LEAQ	end+0(SB), BX
-	MOVQ	BX, ret+0(FP)
-	RET
diff --git a/ogle/probe/probe_linux_amd64.s b/ogle/probe/probe_linux_amd64.s
deleted file mode 100644
index 37999a2..0000000
--- a/ogle/probe/probe_linux_amd64.s
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// TODO #include "../../cmd/ld/textflag.h"
-
-#define	NOSPLIT 4
-
-// Functions that return details about our address space.
-// They use the C-defined symbols like edata and also know
-// a little about the heap and memory layout.
-
-// From the linker. Well-known but might change.
-// TODO: Is there a better way to know this?
-#define	ELFRESERVE	3072
-#define	INITTEXT ((1<<22)+ELFRESERVE)
-
-// base of the address space.
-TEXT ·base(SB), NOSPLIT, $0
-	MOVQ	$INITTEXT, ret+0(FP)
-	RET
-
-// end of the text segment.
-TEXT ·etext(SB), NOSPLIT, $0
-	LEAQ	etext+0(SB), BX
-	MOVQ	BX, ret+0(FP)
-	RET
-
-// end of the data segment.
-TEXT ·edata(SB), NOSPLIT, $0
-	LEAQ	edata+0(SB), BX
-	MOVQ	BX, ret+0(FP)
-	RET
-
-// end of the pre-defined address space.
-TEXT ·end(SB), NOSPLIT, $0
-	LEAQ	end+0(SB), BX
-	MOVQ	BX, ret+0(FP)
-	RET
diff --git a/ogle/probe/size_amd64.go b/ogle/probe/size_amd64.go
deleted file mode 100644
index 08783a5..0000000
--- a/ogle/probe/size_amd64.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package probe
-
-// Sizes of values for the AMD64 architecture.
-
-const (
-	ptrSize = 8
-	maxInt  = 1<<63 - 1
-)
diff --git a/ogle/probe/varint.go b/ogle/probe/varint.go
deleted file mode 100644
index 2d4f1b3..0000000
--- a/ogle/probe/varint.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package probe
-
-// This file contains an implementation of "varint" encoding and decoding.
-// Code is adapted from encoding/binary/varint.go, copied here to avoid dependencies,
-// simplified somewhat, and made local to the package.
-// It handles unsigned integers only.
-
-import (
-	"errors"
-	"io"
-)
-
-// maxVarintLenN is the maximum length of a varint-encoded N-bit integer.
-const (
-	maxVarintLen16 = 3
-	maxVarintLen32 = 5
-	maxVarintLen64 = 10
-)
-
-// putUvarint encodes a uint64 into buf and returns the number of bytes written.
-// If the buffer is too small, putUvarint will panic.
-func putUvarint(buf []byte, x uint64) int {
-	i := 0
-	for x >= 0x80 {
-		buf[i] = byte(x) | 0x80
-		x >>= 7
-		i++
-	}
-	buf[i] = byte(x)
-	return i + 1
-}
-
-// getUvarint decodes a uint64 from buf and returns that value and the
-// number of bytes read (> 0). If an error occurred, the value is 0
-// and the number of bytes n is <= 0 meaning:
-//
-//	n == 0: buf too small
-//	n  < 0: value larger than 64 bits (overflow)
-//              and -n is the number of bytes read
-//
-// TODO: Unused. Delete if it doesn't get used.
-func getUvarint(buf []byte) (uint64, int) {
-	var x uint64
-	var s uint
-	for i, b := range buf {
-		if b < 0x80 {
-			if i > 9 || i == 9 && b > 1 {
-				return 0, -(i + 1) // overflow
-			}
-			return x | uint64(b)<<s, i + 1
-		}
-		x |= uint64(b&0x7f) << s
-		s += 7
-	}
-	return 0, 0
-}
-
-var overflow = errors.New("ogle probe: varint overflows a 64-bit integer")
-
-// readUvarint reads an encoded unsigned integer from r and returns it as a uint64.
-func readUvarint(r io.ByteReader) (uint64, error) {
-	var x uint64
-	var s uint
-	for i := 0; ; i++ {
-		b, err := r.ReadByte()
-		if err != nil {
-			return x, err
-		}
-		if b < 0x80 {
-			if i > 9 || i == 9 && b > 1 {
-				return x, overflow
-			}
-			return x | uint64(b)<<s, nil
-		}
-		x |= uint64(b&0x7f) << s
-		s += 7
-	}
-}
diff --git a/ogle/program/local/local.go b/ogle/program/local/local.go
deleted file mode 100644
index ed9bdc8..0000000
--- a/ogle/program/local/local.go
+++ /dev/null
@@ -1,186 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package local provides access to a local program.
-package local // import "golang.org/x/debug/ogle/program/local"
-
-import (
-	"golang.org/x/debug/ogle/program"
-	"golang.org/x/debug/ogle/program/proxyrpc"
-	"golang.org/x/debug/ogle/program/server"
-)
-
-var _ program.Program = (*Local)(nil)
-var _ program.File = (*File)(nil)
-
-// Local implements the interface program.Program.
-// Through that interface it provides access to a program being debugged.
-type Local struct {
-	s *server.Server
-}
-
-// New creates a new program from the specified file.
-// The program can then be started by the Run method.
-func New(textFile string) (*Local, error) {
-	s, err := server.New(textFile)
-	return &Local{s: s}, err
-}
-
-func (l *Local) Open(name string, mode string) (program.File, error) {
-	req := proxyrpc.OpenRequest{
-		Name: name,
-		Mode: mode,
-	}
-	var resp proxyrpc.OpenResponse
-	err := l.s.Open(&req, &resp)
-	if err != nil {
-		return nil, err
-	}
-	f := &File{
-		prog: l,
-		fd:   resp.FD,
-	}
-	return f, nil
-}
-
-func (l *Local) Run(args ...string) (program.Status, error) {
-	req := proxyrpc.RunRequest{args}
-	var resp proxyrpc.RunResponse
-	err := l.s.Run(&req, &resp)
-	if err != nil {
-		return program.Status{}, err
-	}
-	return resp.Status, nil
-}
-
-func (l *Local) Stop() (program.Status, error) {
-	panic("unimplemented")
-}
-
-func (l *Local) Resume() (program.Status, error) {
-	req := proxyrpc.ResumeRequest{}
-	var resp proxyrpc.ResumeResponse
-	err := l.s.Resume(&req, &resp)
-	if err != nil {
-		return program.Status{}, err
-	}
-	return resp.Status, nil
-}
-
-func (l *Local) Kill() (program.Status, error) {
-	panic("unimplemented")
-}
-
-func (l *Local) Breakpoint(address uint64) ([]uint64, error) {
-	req := proxyrpc.BreakpointRequest{address}
-	var resp proxyrpc.BreakpointResponse
-	err := l.s.Breakpoint(&req, &resp)
-	return resp.PCs, err
-}
-
-func (l *Local) BreakpointAtFunction(name string) ([]uint64, error) {
-	req := proxyrpc.BreakpointAtFunctionRequest{name}
-	var resp proxyrpc.BreakpointResponse
-	err := l.s.BreakpointAtFunction(&req, &resp)
-	return resp.PCs, err
-}
-
-func (l *Local) BreakpointAtLine(file string, line uint64) ([]uint64, error) {
-	req := proxyrpc.BreakpointAtLineRequest{file, line}
-	var resp proxyrpc.BreakpointResponse
-	err := l.s.BreakpointAtLine(&req, &resp)
-	return resp.PCs, err
-}
-
-func (l *Local) DeleteBreakpoints(pcs []uint64) error {
-	req := proxyrpc.DeleteBreakpointsRequest{PCs: pcs}
-	var resp proxyrpc.DeleteBreakpointsResponse
-	return l.s.DeleteBreakpoints(&req, &resp)
-}
-
-func (l *Local) Eval(expr string) ([]string, error) {
-	req := proxyrpc.EvalRequest{
-		Expr: expr,
-	}
-	var resp proxyrpc.EvalResponse
-	err := l.s.Eval(&req, &resp)
-	return resp.Result, err
-}
-
-func (l *Local) Evaluate(e string) (program.Value, error) {
-	req := proxyrpc.EvaluateRequest{
-		Expression: e,
-	}
-	var resp proxyrpc.EvaluateResponse
-	err := l.s.Evaluate(&req, &resp)
-	return resp.Result, err
-}
-
-func (l *Local) Frames(count int) ([]program.Frame, error) {
-	req := proxyrpc.FramesRequest{
-		Count: count,
-	}
-	var resp proxyrpc.FramesResponse
-	err := l.s.Frames(&req, &resp)
-	return resp.Frames, err
-}
-
-func (l *Local) Goroutines() ([]*program.Goroutine, error) {
-	req := proxyrpc.GoroutinesRequest{}
-	var resp proxyrpc.GoroutinesResponse
-	err := l.s.Goroutines(&req, &resp)
-	return resp.Goroutines, err
-}
-
-func (l *Local) VarByName(name string) (program.Var, error) {
-	req := proxyrpc.VarByNameRequest{Name: name}
-	var resp proxyrpc.VarByNameResponse
-	err := l.s.VarByName(&req, &resp)
-	return resp.Var, err
-}
-
-func (l *Local) Value(v program.Var) (program.Value, error) {
-	req := proxyrpc.ValueRequest{Var: v}
-	var resp proxyrpc.ValueResponse
-	err := l.s.Value(&req, &resp)
-	return resp.Value, err
-}
-
-func (l *Local) MapElement(m program.Map, index uint64) (program.Var, program.Var, error) {
-	req := proxyrpc.MapElementRequest{Map: m, Index: index}
-	var resp proxyrpc.MapElementResponse
-	err := l.s.MapElement(&req, &resp)
-	return resp.Key, resp.Value, err
-}
-
-// File implements the program.File interface, providing access
-// to file-like resources associated with the target program.
-type File struct {
-	prog *Local // The Program associated with the file.
-	fd   int    // File descriptor.
-}
-
-func (f *File) ReadAt(p []byte, offset int64) (int, error) {
-	req := proxyrpc.ReadAtRequest{
-		FD:     f.fd,
-		Len:    len(p),
-		Offset: offset,
-	}
-	var resp proxyrpc.ReadAtResponse
-	err := f.prog.s.ReadAt(&req, &resp)
-	return copy(p, resp.Data), err
-}
-
-func (f *File) WriteAt(p []byte, offset int64) (int, error) {
-	panic("unimplemented")
-}
-
-func (f *File) Close() error {
-	req := proxyrpc.CloseRequest{
-		FD: f.fd,
-	}
-	var resp proxyrpc.CloseResponse
-	err := f.prog.s.Close(&req, &resp)
-	return err
-}
diff --git a/ogle/socket/socket.go b/ogle/socket/socket.go
deleted file mode 100644
index 4745dc2..0000000
--- a/ogle/socket/socket.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package socket provides a way for multiple processes from the same user to
-// communicate over a Unix domain socket.
-package socket // import "golang.org/x/debug/ogle/socket"
-
-// TODO: euid instead of uid?
-// TODO: Windows support.
-
-import (
-	"net"
-	"os"
-	"syscall"
-)
-
-// atoi is like strconv.Atoi but we aim to minimize this package's dependencies.
-func atoi(s string) (i int, ok bool) {
-	for _, c := range s {
-		if c < '0' || '9' < c {
-			return 0, false
-		}
-		i = 10*i + int(c-'0')
-	}
-	return i, true
-}
-
-// itoa is like strconv.Itoa but we aim to minimize this package's dependencies.
-func itoa(i int) string {
-	var buf [30]byte
-	n := len(buf)
-	neg := false
-	if i < 0 {
-		i = -i
-		neg = true
-	}
-	ui := uint(i)
-	for ui > 0 || n == len(buf) {
-		n--
-		buf[n] = byte('0' + ui%10)
-		ui /= 10
-	}
-	if neg {
-		n--
-		buf[n] = '-'
-	}
-	return string(buf[n:])
-}
-
-func names(uid, pid int) (dirName, socketName string) {
-	dirName = "/tmp/ogle-socket-uid" + itoa(uid)
-	socketName = dirName + "/pid" + itoa(pid)
-	return
-}
-
-// Listen creates a PID-specific socket under a UID-specific sub-directory of
-// /tmp. That sub-directory is created with 0700 permission bits (before
-// umasking), so that only processes with the same UID can dial that socket.
-func Listen() (net.Listener, error) {
-	dirName, socketName := names(os.Getuid(), os.Getpid())
-	if err := os.MkdirAll(dirName, 0700); err != nil {
-		return nil, err
-	}
-	if err := os.Remove(socketName); err != nil && !os.IsNotExist(err) {
-		return nil, err
-	}
-	return net.Listen("unix", socketName)
-}
-
-// Dial dials the Unix domain socket created by the process with the given UID
-// and PID.
-func Dial(uid, pid int) (net.Conn, error) {
-	_, socketName := names(uid, pid)
-	return net.Dial("unix", socketName)
-}
-
-// CollectGarbage deletes any no-longer-used sockets in the UID-specific sub-
-// directory of /tmp.
-func CollectGarbage() {
-	dirName, _ := names(os.Getuid(), os.Getpid())
-	dir, err := os.Open(dirName)
-	if err != nil {
-		return
-	}
-	defer dir.Close()
-	fileNames, err := dir.Readdirnames(-1)
-	if err != nil {
-		return
-	}
-	for _, fileName := range fileNames {
-		if len(fileName) < 3 || fileName[:3] != "pid" {
-			continue
-		}
-		pid, ok := atoi(fileName[3:])
-		if !ok {
-			continue
-		}
-		// See if there is a process with the given PID. The os.FindProcess function
-		// looks relevant, but on Unix that always succeeds even if there is no such
-		// process. Instead, we send signal 0 and look for ESRCH.
-		if syscall.Kill(pid, 0) != syscall.ESRCH {
-			continue
-		}
-		os.Remove(dirName + "/" + fileName)
-	}
-}
diff --git a/ogle/socket/socket_test.go b/ogle/socket/socket_test.go
deleted file mode 100644
index b07a732..0000000
--- a/ogle/socket/socket_test.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package socket
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"testing"
-	"time"
-)
-
-func TestSocket(t *testing.T) {
-	const msg = "Zoich!"
-
-	l, err := Listen()
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-	defer l.Close()
-
-	wc := make(chan string, 1)
-	go func(c chan string) {
-		w, err := Dial(os.Getuid(), os.Getpid())
-		if err != nil {
-			c <- fmt.Sprintf("dial: %v", err)
-			return
-		}
-		defer w.Close()
-		_, err = w.Write([]byte(msg))
-		if err != nil {
-			c <- fmt.Sprintf("write: %v", err)
-			return
-		}
-		c <- ""
-	}(wc)
-
-	rc := make(chan string, 1)
-	go func(c chan string) {
-		r, err := l.Accept()
-		if err != nil {
-			c <- fmt.Sprintf("accept: %v", err)
-			return
-		}
-		defer r.Close()
-		s, err := ioutil.ReadAll(r)
-		if err != nil {
-			c <- fmt.Sprintf("readAll: %v", err)
-			return
-		}
-		c <- string(s)
-	}(rc)
-
-	for wc != nil || rc != nil {
-		select {
-		case <-time.After(100 * time.Millisecond):
-			t.Fatal("timed out")
-		case errStr := <-wc:
-			if errStr != "" {
-				t.Fatal(errStr)
-			}
-			wc = nil
-		case got := <-rc:
-			if got != msg {
-				t.Fatalf("got %q, want %q", got, msg)
-			}
-			rc = nil
-		}
-	}
-}
-
-// TestCollectGarbage doesn't actually test anything, but it does collect any
-// garbage sockets that are no longer used. It is a courtesy for computers that
-// run this test suite often.
-func TestCollectGarbage(t *testing.T) {
-	CollectGarbage()
-}
diff --git a/ogle/program/program.go b/program.go
similarity index 98%
rename from ogle/program/program.go
rename to program.go
index 72c0389..b988d83 100644
--- a/ogle/program/program.go
+++ b/program.go
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package program provides the portable interface to a program being debugged.
-package program // import "golang.org/x/debug/ogle/program"
+// Package debug provides the portable interface to a program being debugged.
+package debug // import "golang.org/x/debug"
 
 import (
 	"fmt"
diff --git a/ogle/program/client/client.go b/remote/remote.go
similarity index 60%
rename from ogle/program/client/client.go
rename to remote/remote.go
index 51bf1a5..66080c0 100644
--- a/ogle/program/client/client.go
+++ b/remote/remote.go
@@ -2,34 +2,41 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package client provides remote access to an ogle proxy.
-package client // import "golang.org/x/debug/ogle/program/client"
+// Package remote provides remote access to a debugproxy server.
+package remote // import "golang.org/x/debug/remote"
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"net/rpc"
 	"os"
 	"os/exec"
 
-	"golang.org/x/debug/ogle/program"
-	"golang.org/x/debug/ogle/program/proxyrpc"
+	"golang.org/x/debug"
+	"golang.org/x/debug/server/protocol"
 )
 
-var _ program.Program = (*Program)(nil)
-var _ program.File = (*File)(nil)
+var _ debug.Program = (*Program)(nil)
+var _ debug.File = (*File)(nil)
 
-// OgleproxyCmd is the path to the ogleproxy command. It is a variable in case
-// the default value, "ogleproxy", is not in the $PATH.
-var OgleproxyCmd = "ogleproxy"
+// Program implements the debug.Program interface.
+// Through that interface it provides access to a program being
+// debugged on a possibly remote machine by communicating
+// with a debugproxy adjacent to the target program.
+type Program struct {
+	client *rpc.Client
+}
 
-// New connects to the specified host using SSH, starts an ogle proxy
+// DebugproxyCmd is the path to the debugproxy command. It is a variable in case
+// the default value, "debugproxy", is not in the $PATH.
+var DebugproxyCmd = "debugproxy"
+
+// New connects to the specified host using SSH, starts DebugproxyCmd
 // there, and creates a new program from the specified file.
 // The program can then be started by the Run method.
 func New(host string, textFile string) (*Program, error) {
 	// TODO: add args.
-	cmdStrs := []string{"/usr/bin/ssh", host, OgleproxyCmd, "-text", textFile}
+	cmdStrs := []string{"/usr/bin/ssh", host, DebugproxyCmd, "-text", textFile}
 	if host == "localhost" {
 		cmdStrs = cmdStrs[2:]
 	}
@@ -50,21 +57,9 @@
 		return nil, err
 	}
 	stdout.Close()
-	// Read back one line. It must start "OGLE" and we hope says "OK".
-	msg, err := readLine(fromStdout)
-	if err != nil {
+	if msg, err := readLine(fromStdout); err != nil {
 		return nil, err
-	}
-	switch msg {
-	case "OGLE BAD":
-		// Error is on next line.
-		msg, err = readLine(fromStdout)
-		if err == nil {
-			err = errors.New(msg)
-		}
-		return nil, err
-	case "OGLE OK":
-	default:
+	} else if msg != "OK" {
 		// Communication error.
 		return nil, fmt.Errorf("unrecognized message %q", msg)
 	}
@@ -127,20 +122,12 @@
 	return werr
 }
 
-// Program implements the similarly named ogle interface.
-// Through that interface it provides access to a program being
-// debugged on a possibly remote machine by communicating
-// with an ogle proxy adjacent to the target program.
-type Program struct {
-	client *rpc.Client
-}
-
-func (p *Program) Open(name string, mode string) (program.File, error) {
-	req := proxyrpc.OpenRequest{
+func (p *Program) Open(name string, mode string) (debug.File, error) {
+	req := protocol.OpenRequest{
 		Name: name,
 		Mode: mode,
 	}
-	var resp proxyrpc.OpenResponse
+	var resp protocol.OpenResponse
 	err := p.client.Call("Server.Open", &req, &resp)
 	if err != nil {
 		return nil, err
@@ -152,124 +139,124 @@
 	return f, nil
 }
 
-func (p *Program) Run(args ...string) (program.Status, error) {
-	req := proxyrpc.RunRequest{args}
-	var resp proxyrpc.RunResponse
+func (p *Program) Run(args ...string) (debug.Status, error) {
+	req := protocol.RunRequest{args}
+	var resp protocol.RunResponse
 	err := p.client.Call("Server.Run", &req, &resp)
 	if err != nil {
-		return program.Status{}, err
+		return debug.Status{}, err
 	}
 	return resp.Status, nil
 }
 
-func (p *Program) Stop() (program.Status, error) {
+func (p *Program) Stop() (debug.Status, error) {
 	panic("unimplemented")
 }
 
-func (p *Program) Resume() (program.Status, error) {
-	req := proxyrpc.ResumeRequest{}
-	var resp proxyrpc.ResumeResponse
+func (p *Program) Resume() (debug.Status, error) {
+	req := protocol.ResumeRequest{}
+	var resp protocol.ResumeResponse
 	err := p.client.Call("Server.Resume", &req, &resp)
 	if err != nil {
-		return program.Status{}, err
+		return debug.Status{}, err
 	}
 	return resp.Status, nil
 }
 
-func (p *Program) Kill() (program.Status, error) {
+func (p *Program) Kill() (debug.Status, error) {
 	panic("unimplemented")
 }
 
 func (p *Program) Breakpoint(address uint64) ([]uint64, error) {
-	req := proxyrpc.BreakpointRequest{
+	req := protocol.BreakpointRequest{
 		Address: address,
 	}
-	var resp proxyrpc.BreakpointResponse
+	var resp protocol.BreakpointResponse
 	err := p.client.Call("Server.Breakpoint", &req, &resp)
 	return resp.PCs, err
 }
 
 func (p *Program) BreakpointAtFunction(name string) ([]uint64, error) {
-	req := proxyrpc.BreakpointAtFunctionRequest{
+	req := protocol.BreakpointAtFunctionRequest{
 		Function: name,
 	}
-	var resp proxyrpc.BreakpointResponse
+	var resp protocol.BreakpointResponse
 	err := p.client.Call("Server.BreakpointAtFunction", &req, &resp)
 	return resp.PCs, err
 }
 
 func (p *Program) BreakpointAtLine(file string, line uint64) ([]uint64, error) {
-	req := proxyrpc.BreakpointAtLineRequest{
+	req := protocol.BreakpointAtLineRequest{
 		File: file,
 		Line: line,
 	}
-	var resp proxyrpc.BreakpointResponse
+	var resp protocol.BreakpointResponse
 	err := p.client.Call("Server.BreakpointAtLine", &req, &resp)
 	return resp.PCs, err
 }
 
 func (p *Program) DeleteBreakpoints(pcs []uint64) error {
-	req := proxyrpc.DeleteBreakpointsRequest{PCs: pcs}
-	var resp proxyrpc.DeleteBreakpointsResponse
+	req := protocol.DeleteBreakpointsRequest{PCs: pcs}
+	var resp protocol.DeleteBreakpointsResponse
 	return p.client.Call("Server.DeleteBreakpoints", &req, &resp)
 }
 
 func (p *Program) Eval(expr string) ([]string, error) {
-	req := proxyrpc.EvalRequest{
+	req := protocol.EvalRequest{
 		Expr: expr,
 	}
-	var resp proxyrpc.EvalResponse
+	var resp protocol.EvalResponse
 	err := p.client.Call("Server.Eval", &req, &resp)
 	return resp.Result, err
 }
 
-func (p *Program) Evaluate(e string) (program.Value, error) {
-	req := proxyrpc.EvaluateRequest{
+func (p *Program) Evaluate(e string) (debug.Value, error) {
+	req := protocol.EvaluateRequest{
 		Expression: e,
 	}
-	var resp proxyrpc.EvaluateResponse
+	var resp protocol.EvaluateResponse
 	err := p.client.Call("Server.Evaluate", &req, &resp)
 	return resp.Result, err
 }
 
-func (p *Program) Frames(count int) ([]program.Frame, error) {
-	req := proxyrpc.FramesRequest{
+func (p *Program) Frames(count int) ([]debug.Frame, error) {
+	req := protocol.FramesRequest{
 		Count: count,
 	}
-	var resp proxyrpc.FramesResponse
+	var resp protocol.FramesResponse
 	err := p.client.Call("Server.Frames", &req, &resp)
 	return resp.Frames, err
 }
 
-func (p *Program) Goroutines() ([]*program.Goroutine, error) {
-	req := proxyrpc.GoroutinesRequest{}
-	var resp proxyrpc.GoroutinesResponse
+func (p *Program) Goroutines() ([]*debug.Goroutine, error) {
+	req := protocol.GoroutinesRequest{}
+	var resp protocol.GoroutinesResponse
 	err := p.client.Call("Server.Goroutines", &req, &resp)
 	return resp.Goroutines, err
 }
 
-func (p *Program) VarByName(name string) (program.Var, error) {
-	req := proxyrpc.VarByNameRequest{Name: name}
-	var resp proxyrpc.VarByNameResponse
+func (p *Program) VarByName(name string) (debug.Var, error) {
+	req := protocol.VarByNameRequest{Name: name}
+	var resp protocol.VarByNameResponse
 	err := p.client.Call("Server.VarByName", &req, &resp)
 	return resp.Var, err
 }
 
-func (p *Program) Value(v program.Var) (program.Value, error) {
-	req := proxyrpc.ValueRequest{Var: v}
-	var resp proxyrpc.ValueResponse
+func (p *Program) Value(v debug.Var) (debug.Value, error) {
+	req := protocol.ValueRequest{Var: v}
+	var resp protocol.ValueResponse
 	err := p.client.Call("Server.Value", &req, &resp)
 	return resp.Value, err
 }
 
-func (p *Program) MapElement(m program.Map, index uint64) (program.Var, program.Var, error) {
-	req := proxyrpc.MapElementRequest{Map: m, Index: index}
-	var resp proxyrpc.MapElementResponse
+func (p *Program) MapElement(m debug.Map, index uint64) (debug.Var, debug.Var, error) {
+	req := protocol.MapElementRequest{Map: m, Index: index}
+	var resp protocol.MapElementResponse
 	err := p.client.Call("Server.MapElement", &req, &resp)
 	return resp.Key, resp.Value, err
 }
 
-// File implements the program.File interface, providing access
+// File implements the debug.File interface, providing access
 // to file-like resources associated with the target program.
 type File struct {
 	prog *Program // The Program associated with the file.
@@ -277,32 +264,32 @@
 }
 
 func (f *File) ReadAt(p []byte, offset int64) (int, error) {
-	req := proxyrpc.ReadAtRequest{
+	req := protocol.ReadAtRequest{
 		FD:     f.fd,
 		Len:    len(p),
 		Offset: offset,
 	}
-	var resp proxyrpc.ReadAtResponse
+	var resp protocol.ReadAtResponse
 	err := f.prog.client.Call("Server.ReadAt", &req, &resp)
 	return copy(p, resp.Data), err
 }
 
 func (f *File) WriteAt(p []byte, offset int64) (int, error) {
-	req := proxyrpc.WriteAtRequest{
+	req := protocol.WriteAtRequest{
 		FD:     f.fd,
 		Data:   p,
 		Offset: offset,
 	}
-	var resp proxyrpc.WriteAtResponse
+	var resp protocol.WriteAtResponse
 	err := f.prog.client.Call("Server.WriteAt", &req, &resp)
 	return resp.Len, err
 }
 
 func (f *File) Close() error {
-	req := proxyrpc.CloseRequest{
+	req := protocol.CloseRequest{
 		FD: f.fd,
 	}
-	var resp proxyrpc.CloseResponse
+	var resp protocol.CloseResponse
 	err := f.prog.client.Call("Server.Close", &req, &resp)
 	return err
 }
diff --git a/ogle/program/server/dwarf.go b/server/dwarf.go
similarity index 100%
rename from ogle/program/server/dwarf.go
rename to server/dwarf.go
diff --git a/ogle/program/server/eval.go b/server/eval.go
similarity index 96%
rename from ogle/program/server/eval.go
rename to server/eval.go
index 51e8a28..b7a1b68 100644
--- a/ogle/program/server/eval.go
+++ b/server/eval.go
@@ -21,8 +21,8 @@
 	"math"
 	"math/big"
 
+	"golang.org/x/debug"
 	"golang.org/x/debug/dwarf"
-	"golang.org/x/debug/ogle/program"
 )
 
 const prec = 256 // precision for untyped float and complex constants.
@@ -50,7 +50,7 @@
 // For address operations, v will have type pointerToValue.
 // For the operands of address operations, v will have type addressableValue.
 // Other types are represented using the corresponding implementation of
-// program.Value in program.go.
+// debug.Value in program.go.
 //
 // If an evaluation results in an error, the zero value of result is used.
 type result struct {
@@ -84,7 +84,7 @@
 
 // pointerToValue is a pointer to a value in memory.
 // The evaluator constructs these as the result of address operations like "&x".
-// Unlike program.Pointer, the DWARF type stored alongside values of this type
+// Unlike debug.Pointer, the DWARF type stored alongside values of this type
 // is the type of the variable, not the type of the pointer.
 type pointerToValue struct {
 	a uint64
@@ -98,9 +98,9 @@
 }
 
 // A sliceOf is a slice created by slicing an array.
-// Unlike program.Slice, the DWARF type stored alongside a value of this type is
+// Unlike debug.Slice, the DWARF type stored alongside a value of this type is
 // the type of the slice's elements, not the type of the slice.
-type sliceOf program.Slice
+type sliceOf debug.Slice
 
 // ident is a value for representing a special identifier.
 type ident string
@@ -112,7 +112,7 @@
 // evalExpression evaluates a Go expression.
 // If the program counter and stack pointer are nonzero, they are used to determine
 // what local variables are available and where in memory they are.
-func (s *Server) evalExpression(expression string, pc, sp uint64) (program.Value, error) {
+func (s *Server) evalExpression(expression string, pc, sp uint64) (debug.Value, error) {
 	e := evaluator{server: s, expression: expression, pc: pc, sp: sp}
 	node, err := parser.ParseExpr(expression)
 	if err != nil {
@@ -155,11 +155,11 @@
 		}
 		return complex(r, i), nil
 	case untString:
-		return program.String{Length: uint64(len(v)), String: string(v)}, nil
+		return debug.String{Length: uint64(len(v)), String: string(v)}, nil
 	case pointerToValue:
-		return program.Pointer{TypeID: uint64(val.d.Common().Offset), Address: v.a}, nil
+		return debug.Pointer{TypeID: uint64(val.d.Common().Offset), Address: v.a}, nil
 	case sliceOf:
-		return program.Slice(v), nil
+		return debug.Slice(v), nil
 	case nil, addressableValue:
 		// This case should not be reachable.
 		return nil, errors.New("unknown error")
@@ -286,7 +286,7 @@
 	case *ast.StarExpr:
 		x := e.evalNode(n.X, false)
 		switch v := x.v.(type) {
-		case program.Pointer:
+		case debug.Pointer:
 			// x.d may be a typedef pointing to a pointer type (or a typedef pointing
 			// to a typedef pointing to a pointer type, etc.), so remove typedefs
 			// until we get the underlying pointer type.
@@ -307,7 +307,7 @@
 		x := e.evalNode(n.X, false)
 		sel := n.Sel.Name
 		switch v := x.v.(type) {
-		case program.Struct:
+		case debug.Struct:
 			for _, f := range v.Fields {
 				if f.Name == sel {
 					t, err := e.server.dwarfData.Type(dwarf.Offset(f.Var.TypeID))
@@ -318,7 +318,7 @@
 				}
 			}
 			return e.err("struct field not found")
-		case program.Pointer:
+		case debug.Pointer:
 			pt, ok := followTypedefs(x.d).(*dwarf.PtrType) // x.d should be a pointer to struct.
 			if !ok {
 				return e.err("invalid DWARF information for pointer")
@@ -353,7 +353,7 @@
 			return result{}
 		}
 		// The expression is x[index]
-		if m, ok := x.v.(program.Map); ok {
+		if m, ok := x.v.(debug.Map); ok {
 			if getAddress {
 				return e.err("can't take address of map value")
 			}
@@ -406,7 +406,7 @@
 			return e.err("invalid index: " + err.Error())
 		}
 		switch v := x.v.(type) {
-		case program.Array:
+		case debug.Array:
 			if u >= v.Length {
 				return e.err("array index out of bounds")
 			}
@@ -415,7 +415,7 @@
 				return e.err(err.Error())
 			}
 			return e.resultFrom(v.Element(u).Address, elemType, getAddress)
-		case program.Slice:
+		case debug.Slice:
 			if u >= v.Length {
 				return e.err("slice index out of bounds")
 			}
@@ -429,7 +429,7 @@
 				return e.err("slice index out of bounds")
 			}
 			return e.resultFrom(v.Element(u).Address, x.d, getAddress)
-		case program.String:
+		case debug.String:
 			if getAddress {
 				return e.err("can't take address of string element")
 			}
@@ -482,19 +482,19 @@
 		}
 		x := e.evalNode(n.X, false)
 		switch v := x.v.(type) {
-		case program.Array, program.Pointer, pointerToValue:
+		case debug.Array, debug.Pointer, pointerToValue:
 			// This case handles the slicing of arrays and pointers to arrays.
-			var arr program.Array
+			var arr debug.Array
 			switch v := x.v.(type) {
-			case program.Array:
+			case debug.Array:
 				arr = v
-			case program.Pointer:
+			case debug.Pointer:
 				pt, ok := followTypedefs(x.d).(*dwarf.PtrType)
 				if !ok {
 					return e.err("invalid DWARF type for pointer")
 				}
 				a := e.resultFrom(v.Address, pt.Type, false)
-				arr, ok = a.v.(program.Array)
+				arr, ok = a.v.(debug.Array)
 				if !ok {
 					// v is a pointer to something other than an array.
 					return e.err("cannot slice pointer")
@@ -502,7 +502,7 @@
 			case pointerToValue:
 				a := e.resultFrom(v.a, x.d, false)
 				var ok bool
-				arr, ok = a.v.(program.Array)
+				arr, ok = a.v.(debug.Array)
 				if !ok {
 					// v is a pointer to something other than an array.
 					return e.err("cannot slice pointer")
@@ -528,7 +528,7 @@
 			return result{
 				d: elemType,
 				v: sliceOf{
-					Array: program.Array{
+					Array: debug.Array{
 						ElementTypeID: arr.ElementTypeID,
 						Address:       arr.Element(low).Address,
 						Length:        high - low,
@@ -537,7 +537,7 @@
 					Capacity: max - low,
 				},
 			}
-		case program.Slice:
+		case debug.Slice:
 			if n.High == nil {
 				high = v.Length
 			} else if high > v.Capacity {
@@ -573,7 +573,7 @@
 			v.Length = high - low
 			v.Capacity = max - low
 			return result{x.d, v}
-		case program.String:
+		case debug.String:
 			if n.Max != nil {
 				return e.err("full slice of string")
 			}
@@ -1331,12 +1331,12 @@
 		}
 		return result{x.d, c}
 
-	case program.String:
-		b, ok := y.v.(program.String)
+	case debug.String:
+		b, ok := y.v.(debug.String)
 		if !ok {
 			return e.err("type mismatch")
 		}
-		var c program.String
+		var c debug.String
 		switch op {
 		// TODO: these comparison operators only use the part of the string that
 		// was read.  Very large strings do not have their entire contents read by
@@ -1690,7 +1690,7 @@
 	if !ok {
 		e.err("couldn't construct string")
 	}
-	return result{t, program.String{Length: uint64(len(s)), String: s}}
+	return result{t, debug.String{Length: uint64(len(s)), String: s}}
 }
 
 // getBaseType returns the *dwarf.Type with a given name.
@@ -1777,24 +1777,24 @@
 	case *dwarf.BoolType:
 		v = false
 	case *dwarf.PtrType:
-		v = program.Pointer{TypeID: uint64(t.Common().Offset)}
+		v = debug.Pointer{TypeID: uint64(t.Common().Offset)}
 	case *dwarf.SliceType:
-		v = program.Slice{
-			Array: program.Array{
+		v = debug.Slice{
+			Array: debug.Array{
 				ElementTypeID: uint64(typ.ElemType.Common().Offset),
 				StrideBits:    uint64(typ.ElemType.Common().ByteSize) * 8,
 			},
 		}
 	case *dwarf.StringType:
-		v = program.String{}
+		v = debug.String{}
 	case *dwarf.InterfaceType:
-		v = program.Interface{}
+		v = debug.Interface{}
 	case *dwarf.FuncType:
-		v = program.Func{}
+		v = debug.Func{}
 	case *dwarf.MapType:
-		v = program.Map{TypeID: uint64(t.Common().Offset)}
+		v = debug.Map{TypeID: uint64(t.Common().Offset)}
 	case *dwarf.ChanType:
-		v = program.Channel{
+		v = debug.Channel{
 			ElementTypeID: uint64(typ.ElemType.Common().Offset),
 			Stride:        uint64(typ.ElemType.Common().ByteSize),
 		}
@@ -1984,8 +1984,8 @@
 		}
 	case untString:
 		switch y.v.(type) {
-		case program.String:
-			return result{y.d, program.String{Length: uint64(len(a)), String: string(a)}}
+		case debug.String:
+			return result{y.d, debug.String{Length: uint64(len(a)), String: string(a)}}
 		}
 	}
 	return x
diff --git a/ogle/program/server/eval.m4 b/server/eval.m4
similarity index 96%
rename from ogle/program/server/eval.m4
rename to server/eval.m4
index ec48880..0e0def3 100644
--- a/ogle/program/server/eval.m4
+++ b/server/eval.m4
@@ -21,8 +21,8 @@
 	"math"
 	"math/big"
 
+	"golang.org/x/debug"
 	"golang.org/x/debug/dwarf"
-	"golang.org/x/debug/ogle/program"
 )
 
 const prec = 256 // precision for untyped float and complex constants.
@@ -50,7 +50,7 @@
 // For address operations, v will have type pointerToValue.
 // For the operands of address operations, v will have type addressableValue.
 // Other types are represented using the corresponding implementation of
-// program.Value in program.go.
+// debug.Value in program.go.
 //
 // If an evaluation results in an error, the zero value of result is used.
 type result struct {
@@ -84,7 +84,7 @@
 
 // pointerToValue is a pointer to a value in memory.
 // The evaluator constructs these as the result of address operations like "&x".
-// Unlike program.Pointer, the DWARF type stored alongside values of this type
+// Unlike debug.Pointer, the DWARF type stored alongside values of this type
 // is the type of the variable, not the type of the pointer.
 type pointerToValue struct {
 	a uint64
@@ -98,9 +98,9 @@
 }
 
 // A sliceOf is a slice created by slicing an array.
-// Unlike program.Slice, the DWARF type stored alongside a value of this type is
+// Unlike debug.Slice, the DWARF type stored alongside a value of this type is
 // the type of the slice's elements, not the type of the slice.
-type sliceOf program.Slice
+type sliceOf debug.Slice
 
 // ident is a value for representing a special identifier.
 type ident string
@@ -112,7 +112,7 @@
 // evalExpression evaluates a Go expression.
 // If the program counter and stack pointer are nonzero, they are used to determine
 // what local variables are available and where in memory they are.
-func (s *Server) evalExpression(expression string, pc, sp uint64) (program.Value, error) {
+func (s *Server) evalExpression(expression string, pc, sp uint64) (debug.Value, error) {
 	e := evaluator{server: s, expression: expression, pc: pc, sp: sp}
 	node, err := parser.ParseExpr(expression)
 	if err != nil {
@@ -155,11 +155,11 @@
 		}
 		return complex(r, i), nil
 	case untString:
-		return program.String{Length: uint64(len(v)), String: string(v)}, nil
+		return debug.String{Length: uint64(len(v)), String: string(v)}, nil
 	case pointerToValue:
-		return program.Pointer{TypeID: uint64(val.d.Common().Offset), Address: v.a}, nil
+		return debug.Pointer{TypeID: uint64(val.d.Common().Offset), Address: v.a}, nil
 	case sliceOf:
-		return program.Slice(v), nil
+		return debug.Slice(v), nil
 	case nil, addressableValue:
 		// This case should not be reachable.
 		return nil, errors.New("unknown error")
@@ -286,7 +286,7 @@
 	case *ast.StarExpr:
 		x := e.evalNode(n.X, false)
 		switch v := x.v.(type) {
-		case program.Pointer:
+		case debug.Pointer:
 			// x.d may be a typedef pointing to a pointer type (or a typedef pointing
 			// to a typedef pointing to a pointer type, etc.), so remove typedefs
 			// until we get the underlying pointer type.
@@ -307,7 +307,7 @@
 		x := e.evalNode(n.X, false)
 		sel := n.Sel.Name
 		switch v := x.v.(type) {
-		case program.Struct:
+		case debug.Struct:
 			for _, f := range v.Fields {
 				if f.Name == sel {
 					t, err := e.server.dwarfData.Type(dwarf.Offset(f.Var.TypeID))
@@ -318,7 +318,7 @@
 				}
 			}
 			return e.err("struct field not found")
-		case program.Pointer:
+		case debug.Pointer:
 			pt, ok := followTypedefs(x.d).(*dwarf.PtrType) // x.d should be a pointer to struct.
 			if !ok {
 				return e.err("invalid DWARF information for pointer")
@@ -353,7 +353,7 @@
 			return result{}
 		}
 		// The expression is x[index]
-		if m, ok := x.v.(program.Map); ok {
+		if m, ok := x.v.(debug.Map); ok {
 			if getAddress {
 				return e.err("can't take address of map value")
 			}
@@ -406,7 +406,7 @@
 			return e.err("invalid index: " + err.Error())
 		}
 		switch v := x.v.(type) {
-		case program.Array:
+		case debug.Array:
 			if u >= v.Length {
 				return e.err("array index out of bounds")
 			}
@@ -415,7 +415,7 @@
 				return e.err(err.Error())
 			}
 			return e.resultFrom(v.Element(u).Address, elemType, getAddress)
-		case program.Slice:
+		case debug.Slice:
 			if u >= v.Length {
 				return e.err("slice index out of bounds")
 			}
@@ -429,7 +429,7 @@
 				return e.err("slice index out of bounds")
 			}
 			return e.resultFrom(v.Element(u).Address, x.d, getAddress)
-		case program.String:
+		case debug.String:
 			if getAddress {
 				return e.err("can't take address of string element")
 			}
@@ -482,19 +482,19 @@
 		}
 		x := e.evalNode(n.X, false)
 		switch v := x.v.(type) {
-		case program.Array, program.Pointer, pointerToValue:
+		case debug.Array, debug.Pointer, pointerToValue:
 			// This case handles the slicing of arrays and pointers to arrays.
-			var arr program.Array
+			var arr debug.Array
 			switch v := x.v.(type) {
-			case program.Array:
+			case debug.Array:
 				arr = v
-			case program.Pointer:
+			case debug.Pointer:
 				pt, ok := followTypedefs(x.d).(*dwarf.PtrType)
 				if !ok {
 					return e.err("invalid DWARF type for pointer")
 				}
 				a := e.resultFrom(v.Address, pt.Type, false)
-				arr, ok = a.v.(program.Array)
+				arr, ok = a.v.(debug.Array)
 				if !ok {
 					// v is a pointer to something other than an array.
 					return e.err("cannot slice pointer")
@@ -502,7 +502,7 @@
 			case pointerToValue:
 				a := e.resultFrom(v.a, x.d, false)
 				var ok bool
-				arr, ok = a.v.(program.Array)
+				arr, ok = a.v.(debug.Array)
 				if !ok {
 					// v is a pointer to something other than an array.
 					return e.err("cannot slice pointer")
@@ -528,7 +528,7 @@
 			return result{
 				d: elemType,
 				v: sliceOf{
-					Array: program.Array{
+					Array: debug.Array{
 						ElementTypeID: arr.ElementTypeID,
 						Address:       arr.Element(low).Address,
 						Length:        high - low,
@@ -537,7 +537,7 @@
 					Capacity: max - low,
 				},
 			}
-		case program.Slice:
+		case debug.Slice:
 			if n.High == nil {
 				high = v.Length
 			} else if high > v.Capacity {
@@ -573,7 +573,7 @@
 			v.Length = high - low
 			v.Capacity = max - low
 			return result{x.d, v}
-		case program.String:
+		case debug.String:
 			if n.Max != nil {
 				return e.err("full slice of string")
 			}
@@ -939,12 +939,12 @@
 		}
 		return result{x.d, c}
 
-	case program.String:
-		b, ok := y.v.(program.String)
+	case debug.String:
+		b, ok := y.v.(debug.String)
 		if !ok {
 			return e.err("type mismatch")
 		}
-		var c program.String
+		var c debug.String
 		switch op {
 		// TODO: these comparison operators only use the part of the string that
 		// was read.  Very large strings do not have their entire contents read by
@@ -1298,7 +1298,7 @@
 	if !ok {
 		e.err("couldn't construct string")
 	}
-	return result{t, program.String{Length: uint64(len(s)), String: s}}
+	return result{t, debug.String{Length: uint64(len(s)), String: s}}
 }
 
 // getBaseType returns the *dwarf.Type with a given name.
@@ -1385,24 +1385,24 @@
 	case *dwarf.BoolType:
 		v = false
 	case *dwarf.PtrType:
-		v = program.Pointer{TypeID: uint64(t.Common().Offset)}
+		v = debug.Pointer{TypeID: uint64(t.Common().Offset)}
 	case *dwarf.SliceType:
-		v = program.Slice{
-			Array: program.Array{
+		v = debug.Slice{
+			Array: debug.Array{
 				ElementTypeID: uint64(typ.ElemType.Common().Offset),
 				StrideBits:    uint64(typ.ElemType.Common().ByteSize) * 8,
 			},
 		}
 	case *dwarf.StringType:
-		v = program.String{}
+		v = debug.String{}
 	case *dwarf.InterfaceType:
-		v = program.Interface{}
+		v = debug.Interface{}
 	case *dwarf.FuncType:
-		v = program.Func{}
+		v = debug.Func{}
 	case *dwarf.MapType:
-		v = program.Map{TypeID: uint64(t.Common().Offset)}
+		v = debug.Map{TypeID: uint64(t.Common().Offset)}
 	case *dwarf.ChanType:
-		v = program.Channel{
+		v = debug.Channel{
 			ElementTypeID: uint64(typ.ElemType.Common().Offset),
 			Stride:        uint64(typ.ElemType.Common().ByteSize),
 		}
@@ -1592,8 +1592,8 @@
 		}
 	case untString:
 		switch y.v.(type) {
-		case program.String:
-			return result{y.d, program.String{Length: uint64(len(a)), String: string(a)}}
+		case debug.String:
+			return result{y.d, debug.String{Length: uint64(len(a)), String: string(a)}}
 		}
 	}
 	return x
diff --git a/ogle/program/server/peek.go b/server/peek.go
similarity index 100%
rename from ogle/program/server/peek.go
rename to server/peek.go
diff --git a/ogle/program/server/print.go b/server/print.go
similarity index 99%
rename from ogle/program/server/print.go
rename to server/print.go
index 0ec0e5c..927988a 100644
--- a/ogle/program/server/print.go
+++ b/server/print.go
@@ -8,8 +8,8 @@
 	"bytes"
 	"fmt"
 
+	"golang.org/x/debug/arch"
 	"golang.org/x/debug/dwarf"
-	"golang.org/x/debug/ogle/arch"
 )
 
 // typeAndAddress associates an address in the target with a DWARF type.
diff --git a/ogle/program/proxyrpc/proxyrpc.go b/server/protocol/protocol.go
similarity index 69%
rename from ogle/program/proxyrpc/proxyrpc.go
rename to server/protocol/protocol.go
index b6636f8..c08b895 100644
--- a/ogle/program/proxyrpc/proxyrpc.go
+++ b/server/protocol/protocol.go
@@ -2,27 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package proxyrpc defines the types used to represent the RPC calls
-// used to the ogleproxy.
-package proxyrpc // import "golang.org/x/debug/ogle/program/proxyrpc"
+// Package protocol defines the types used to represent calls to the debug server.
+package protocol // import "golang.org/x/debug/server/protocol"
 
 import (
 	"encoding/gob"
 
-	"golang.org/x/debug/ogle/program"
+	"golang.org/x/debug"
 )
 
 func init() {
-	// Register implementations of program.Value with gob.
-	gob.Register(program.Pointer{})
-	gob.Register(program.Array{})
-	gob.Register(program.Struct{})
-	gob.Register(program.Slice{})
-	gob.Register(program.Map{})
-	gob.Register(program.String{})
-	gob.Register(program.Channel{})
-	gob.Register(program.Func{})
-	gob.Register(program.Interface{})
+	// Register implementations of debug.Value with gob.
+	gob.Register(debug.Pointer{})
+	gob.Register(debug.Array{})
+	gob.Register(debug.Struct{})
+	gob.Register(debug.Slice{})
+	gob.Register(debug.Map{})
+	gob.Register(debug.String{})
+	gob.Register(debug.Channel{})
+	gob.Register(debug.Func{})
+	gob.Register(debug.Interface{})
 }
 
 // For regularity, each method has a unique Request and a Response type even
@@ -73,14 +72,14 @@
 }
 
 type RunResponse struct {
-	Status program.Status
+	Status debug.Status
 }
 
 type ResumeRequest struct {
 }
 
 type ResumeResponse struct {
-	Status program.Status
+	Status debug.Status
 }
 
 type BreakpointRequest struct {
@@ -120,7 +119,7 @@
 }
 
 type EvaluateResponse struct {
-	Result program.Value
+	Result debug.Value
 }
 
 type FramesRequest struct {
@@ -128,7 +127,7 @@
 }
 
 type FramesResponse struct {
-	Frames []program.Frame
+	Frames []debug.Frame
 }
 
 type VarByNameRequest struct {
@@ -136,30 +135,30 @@
 }
 
 type VarByNameResponse struct {
-	Var program.Var
+	Var debug.Var
 }
 
 type ValueRequest struct {
-	Var program.Var
+	Var debug.Var
 }
 
 type ValueResponse struct {
-	Value program.Value
+	Value debug.Value
 }
 
 type MapElementRequest struct {
-	Map   program.Map
+	Map   debug.Map
 	Index uint64
 }
 
 type MapElementResponse struct {
-	Key   program.Var
-	Value program.Var
+	Key   debug.Var
+	Value debug.Var
 }
 
 type GoroutinesRequest struct {
 }
 
 type GoroutinesResponse struct {
-	Goroutines []*program.Goroutine
+	Goroutines []*debug.Goroutine
 }
diff --git a/ogle/program/server/ptrace.go b/server/ptrace.go
similarity index 100%
rename from ogle/program/server/ptrace.go
rename to server/ptrace.go
diff --git a/ogle/program/server/server.go b/server/server.go
similarity index 78%
rename from ogle/program/server/server.go
rename to server/server.go
index 2d86704..584ed5b 100644
--- a/ogle/program/server/server.go
+++ b/server/server.go
@@ -4,7 +4,7 @@
 
 // Package server provides RPC access to a local program being debugged.
 // It is the remote end of the client implementation of the Program interface.
-package server // import "golang.org/x/debug/ogle/program/server"
+package server // import "golang.org/x/debug/server"
 
 //go:generate sh -c "m4 -P eval.m4 > eval.go"
 
@@ -19,12 +19,12 @@
 	"sync"
 	"syscall"
 
+	"golang.org/x/debug"
+	"golang.org/x/debug/arch"
 	"golang.org/x/debug/dwarf"
 	"golang.org/x/debug/elf"
 	"golang.org/x/debug/macho"
-	"golang.org/x/debug/ogle/arch"
-	"golang.org/x/debug/ogle/program"
-	"golang.org/x/debug/ogle/program/proxyrpc"
+	"golang.org/x/debug/server/protocol"
 )
 
 type breakpoint struct {
@@ -58,7 +58,7 @@
 	printer         *Printer
 
 	// goroutineStack reads the stack of a (non-running) goroutine.
-	goroutineStack     func(uint64) ([]program.Frame, error)
+	goroutineStack     func(uint64) ([]debug.Frame, error)
 	goroutineStackOnce sync.Once
 }
 
@@ -154,38 +154,38 @@
 
 func (s *Server) dispatch(c call) {
 	switch req := c.req.(type) {
-	case *proxyrpc.BreakpointRequest:
-		c.errc <- s.handleBreakpoint(req, c.resp.(*proxyrpc.BreakpointResponse))
-	case *proxyrpc.BreakpointAtFunctionRequest:
-		c.errc <- s.handleBreakpointAtFunction(req, c.resp.(*proxyrpc.BreakpointResponse))
-	case *proxyrpc.BreakpointAtLineRequest:
-		c.errc <- s.handleBreakpointAtLine(req, c.resp.(*proxyrpc.BreakpointResponse))
-	case *proxyrpc.DeleteBreakpointsRequest:
-		c.errc <- s.handleDeleteBreakpoints(req, c.resp.(*proxyrpc.DeleteBreakpointsResponse))
-	case *proxyrpc.CloseRequest:
-		c.errc <- s.handleClose(req, c.resp.(*proxyrpc.CloseResponse))
-	case *proxyrpc.EvalRequest:
-		c.errc <- s.handleEval(req, c.resp.(*proxyrpc.EvalResponse))
-	case *proxyrpc.EvaluateRequest:
-		c.errc <- s.handleEvaluate(req, c.resp.(*proxyrpc.EvaluateResponse))
-	case *proxyrpc.FramesRequest:
-		c.errc <- s.handleFrames(req, c.resp.(*proxyrpc.FramesResponse))
-	case *proxyrpc.OpenRequest:
-		c.errc <- s.handleOpen(req, c.resp.(*proxyrpc.OpenResponse))
-	case *proxyrpc.ReadAtRequest:
-		c.errc <- s.handleReadAt(req, c.resp.(*proxyrpc.ReadAtResponse))
-	case *proxyrpc.ResumeRequest:
-		c.errc <- s.handleResume(req, c.resp.(*proxyrpc.ResumeResponse))
-	case *proxyrpc.RunRequest:
-		c.errc <- s.handleRun(req, c.resp.(*proxyrpc.RunResponse))
-	case *proxyrpc.VarByNameRequest:
-		c.errc <- s.handleVarByName(req, c.resp.(*proxyrpc.VarByNameResponse))
-	case *proxyrpc.ValueRequest:
-		c.errc <- s.handleValue(req, c.resp.(*proxyrpc.ValueResponse))
-	case *proxyrpc.MapElementRequest:
-		c.errc <- s.handleMapElement(req, c.resp.(*proxyrpc.MapElementResponse))
-	case *proxyrpc.GoroutinesRequest:
-		c.errc <- s.handleGoroutines(req, c.resp.(*proxyrpc.GoroutinesResponse))
+	case *protocol.BreakpointRequest:
+		c.errc <- s.handleBreakpoint(req, c.resp.(*protocol.BreakpointResponse))
+	case *protocol.BreakpointAtFunctionRequest:
+		c.errc <- s.handleBreakpointAtFunction(req, c.resp.(*protocol.BreakpointResponse))
+	case *protocol.BreakpointAtLineRequest:
+		c.errc <- s.handleBreakpointAtLine(req, c.resp.(*protocol.BreakpointResponse))
+	case *protocol.DeleteBreakpointsRequest:
+		c.errc <- s.handleDeleteBreakpoints(req, c.resp.(*protocol.DeleteBreakpointsResponse))
+	case *protocol.CloseRequest:
+		c.errc <- s.handleClose(req, c.resp.(*protocol.CloseResponse))
+	case *protocol.EvalRequest:
+		c.errc <- s.handleEval(req, c.resp.(*protocol.EvalResponse))
+	case *protocol.EvaluateRequest:
+		c.errc <- s.handleEvaluate(req, c.resp.(*protocol.EvaluateResponse))
+	case *protocol.FramesRequest:
+		c.errc <- s.handleFrames(req, c.resp.(*protocol.FramesResponse))
+	case *protocol.OpenRequest:
+		c.errc <- s.handleOpen(req, c.resp.(*protocol.OpenResponse))
+	case *protocol.ReadAtRequest:
+		c.errc <- s.handleReadAt(req, c.resp.(*protocol.ReadAtResponse))
+	case *protocol.ResumeRequest:
+		c.errc <- s.handleResume(req, c.resp.(*protocol.ResumeResponse))
+	case *protocol.RunRequest:
+		c.errc <- s.handleRun(req, c.resp.(*protocol.RunResponse))
+	case *protocol.VarByNameRequest:
+		c.errc <- s.handleVarByName(req, c.resp.(*protocol.VarByNameResponse))
+	case *protocol.ValueRequest:
+		c.errc <- s.handleValue(req, c.resp.(*protocol.ValueResponse))
+	case *protocol.MapElementRequest:
+		c.errc <- s.handleMapElement(req, c.resp.(*protocol.MapElementResponse))
+	case *protocol.GoroutinesRequest:
+		c.errc <- s.handleGoroutines(req, c.resp.(*protocol.GoroutinesResponse))
 	default:
 		panic(fmt.Sprintf("unexpected call request type %T", c.req))
 	}
@@ -200,14 +200,14 @@
 type file struct {
 	mode  string
 	index int
-	f     program.File
+	f     debug.File
 }
 
-func (s *Server) Open(req *proxyrpc.OpenRequest, resp *proxyrpc.OpenResponse) error {
+func (s *Server) Open(req *protocol.OpenRequest, resp *protocol.OpenResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleOpen(req *proxyrpc.OpenRequest, resp *proxyrpc.OpenResponse) error {
+func (s *Server) handleOpen(req *protocol.OpenRequest, resp *protocol.OpenResponse) error {
 	// TODO: Better simulation. For now we just open the named OS file.
 	var flag int
 	switch req.Mode {
@@ -241,11 +241,11 @@
 	return nil
 }
 
-func (s *Server) ReadAt(req *proxyrpc.ReadAtRequest, resp *proxyrpc.ReadAtResponse) error {
+func (s *Server) ReadAt(req *protocol.ReadAtRequest, resp *protocol.ReadAtResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleReadAt(req *proxyrpc.ReadAtRequest, resp *proxyrpc.ReadAtResponse) error {
+func (s *Server) handleReadAt(req *protocol.ReadAtRequest, resp *protocol.ReadAtResponse) error {
 	fd := req.FD
 	if fd < 0 || len(s.files) <= fd || s.files[fd] == nil {
 		return fmt.Errorf("ReadAt: bad file descriptor %d", fd)
@@ -257,11 +257,11 @@
 	return err
 }
 
-func (s *Server) Close(req *proxyrpc.CloseRequest, resp *proxyrpc.CloseResponse) error {
+func (s *Server) Close(req *protocol.CloseRequest, resp *protocol.CloseResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleClose(req *proxyrpc.CloseRequest, resp *proxyrpc.CloseResponse) error {
+func (s *Server) handleClose(req *protocol.CloseRequest, resp *protocol.CloseResponse) error {
 	fd := req.FD
 	if fd < 0 || fd >= len(s.files) || s.files[fd] == nil {
 		return fmt.Errorf("Close: bad file descriptor %d", fd)
@@ -272,11 +272,11 @@
 	return err
 }
 
-func (s *Server) Run(req *proxyrpc.RunRequest, resp *proxyrpc.RunResponse) error {
+func (s *Server) Run(req *protocol.RunRequest, resp *protocol.RunResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleRun(req *proxyrpc.RunRequest, resp *proxyrpc.RunResponse) error {
+func (s *Server) handleRun(req *protocol.RunRequest, resp *protocol.RunResponse) error {
 	if s.proc != nil {
 		s.proc.Kill()
 		s.proc = nil
@@ -305,11 +305,11 @@
 	return nil
 }
 
-func (s *Server) Resume(req *proxyrpc.ResumeRequest, resp *proxyrpc.ResumeResponse) error {
+func (s *Server) Resume(req *protocol.ResumeRequest, resp *protocol.ResumeResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleResume(req *proxyrpc.ResumeRequest, resp *proxyrpc.ResumeResponse) error {
+func (s *Server) handleResume(req *protocol.ResumeRequest, resp *protocol.ResumeResponse) error {
 	if s.proc == nil {
 		return fmt.Errorf("Resume: Run did not successfully start a process")
 	}
@@ -412,19 +412,19 @@
 	}
 }
 
-func (s *Server) Breakpoint(req *proxyrpc.BreakpointRequest, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) Breakpoint(req *protocol.BreakpointRequest, resp *protocol.BreakpointResponse) error {
 	return s.call(s.breakpointc, req, resp)
 }
 
-func (s *Server) handleBreakpoint(req *proxyrpc.BreakpointRequest, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) handleBreakpoint(req *protocol.BreakpointRequest, resp *protocol.BreakpointResponse) error {
 	return s.addBreakpoints([]uint64{req.Address}, resp)
 }
 
-func (s *Server) BreakpointAtFunction(req *proxyrpc.BreakpointAtFunctionRequest, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) BreakpointAtFunction(req *protocol.BreakpointAtFunctionRequest, resp *protocol.BreakpointResponse) error {
 	return s.call(s.breakpointc, req, resp)
 }
 
-func (s *Server) handleBreakpointAtFunction(req *proxyrpc.BreakpointAtFunctionRequest, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) handleBreakpointAtFunction(req *protocol.BreakpointAtFunctionRequest, resp *protocol.BreakpointResponse) error {
 	pc, err := s.lookupFunction(req.Function)
 	if err != nil {
 		return err
@@ -432,11 +432,11 @@
 	return s.addBreakpoints([]uint64{pc}, resp)
 }
 
-func (s *Server) BreakpointAtLine(req *proxyrpc.BreakpointAtLineRequest, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) BreakpointAtLine(req *protocol.BreakpointAtLineRequest, resp *protocol.BreakpointResponse) error {
 	return s.call(s.breakpointc, req, resp)
 }
 
-func (s *Server) handleBreakpointAtLine(req *proxyrpc.BreakpointAtLineRequest, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) handleBreakpointAtLine(req *protocol.BreakpointAtLineRequest, resp *protocol.BreakpointResponse) error {
 	if s.dwarfData == nil {
 		return fmt.Errorf("no DWARF data")
 	}
@@ -448,7 +448,7 @@
 }
 
 // addBreakpoints adds breakpoints at the addresses in pcs, then stores pcs in the response.
-func (s *Server) addBreakpoints(pcs []uint64, resp *proxyrpc.BreakpointResponse) error {
+func (s *Server) addBreakpoints(pcs []uint64, resp *protocol.BreakpointResponse) error {
 	// Get the original code at each address with ptracePeek.
 	bps := make([]breakpoint, 0, len(pcs))
 	for _, pc := range pcs {
@@ -470,11 +470,11 @@
 	return nil
 }
 
-func (s *Server) DeleteBreakpoints(req *proxyrpc.DeleteBreakpointsRequest, resp *proxyrpc.DeleteBreakpointsResponse) error {
+func (s *Server) DeleteBreakpoints(req *protocol.DeleteBreakpointsRequest, resp *protocol.DeleteBreakpointsResponse) error {
 	return s.call(s.breakpointc, req, resp)
 }
 
-func (s *Server) handleDeleteBreakpoints(req *proxyrpc.DeleteBreakpointsRequest, resp *proxyrpc.DeleteBreakpointsResponse) error {
+func (s *Server) handleDeleteBreakpoints(req *protocol.DeleteBreakpointsRequest, resp *protocol.DeleteBreakpointsResponse) error {
 	for _, pc := range req.PCs {
 		delete(s.breakpoints, pc)
 	}
@@ -501,11 +501,11 @@
 	return nil
 }
 
-func (s *Server) Eval(req *proxyrpc.EvalRequest, resp *proxyrpc.EvalResponse) error {
+func (s *Server) Eval(req *protocol.EvalRequest, resp *protocol.EvalResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleEval(req *proxyrpc.EvalRequest, resp *proxyrpc.EvalResponse) (err error) {
+func (s *Server) handleEval(req *protocol.EvalRequest, resp *protocol.EvalResponse) (err error) {
 	resp.Result, err = s.eval(req.Expr)
 	return err
 }
@@ -566,11 +566,11 @@
 	return nil, fmt.Errorf("bad expression syntax: %q", expr)
 }
 
-func (s *Server) Evaluate(req *proxyrpc.EvaluateRequest, resp *proxyrpc.EvaluateResponse) error {
+func (s *Server) Evaluate(req *protocol.EvaluateRequest, resp *protocol.EvaluateResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleEvaluate(req *proxyrpc.EvaluateRequest, resp *proxyrpc.EvaluateResponse) (err error) {
+func (s *Server) handleEvaluate(req *protocol.EvaluateRequest, resp *protocol.EvaluateResponse) (err error) {
 	resp.Result, err = s.evalExpression(req.Expression, s.stoppedRegs.Rip, s.stoppedRegs.Rsp)
 	return err
 }
@@ -602,11 +602,11 @@
 	return addr, nil
 }
 
-func (s *Server) Frames(req *proxyrpc.FramesRequest, resp *proxyrpc.FramesResponse) error {
+func (s *Server) Frames(req *protocol.FramesRequest, resp *protocol.FramesResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleFrames(req *proxyrpc.FramesRequest, resp *proxyrpc.FramesResponse) error {
+func (s *Server) handleFrames(req *protocol.FramesRequest, resp *protocol.FramesResponse) error {
 	// TODO: verify that we're stopped.
 	if s.topOfStackAddrs == nil {
 		if err := s.evaluateTopOfStackAddrs(); err != nil {
@@ -624,8 +624,8 @@
 }
 
 // walkStack returns up to the requested number of stack frames.
-func (s *Server) walkStack(pc, sp uint64, count int) ([]program.Frame, error) {
-	var frames []program.Frame
+func (s *Server) walkStack(pc, sp uint64, count int) ([]debug.Frame, error) {
+	var frames []debug.Frame
 
 	var buf [8]byte
 	b := new(bytes.Buffer)
@@ -647,7 +647,7 @@
 		if err != nil {
 			return frames, err
 		}
-		frame := program.Frame{
+		frame := debug.Frame{
 			PC:            pc,
 			SP:            sp,
 			File:          file,
@@ -667,7 +667,7 @@
 			// TODO: report variables we couldn't parse?
 			if entry.Tag == dwarf.TagFormalParameter {
 				if v, err := s.parseParameterOrLocal(entry, fp); err == nil {
-					frame.Params = append(frame.Params, program.Param(v))
+					frame.Params = append(frame.Params, debug.Param(v))
 				}
 			}
 			if entry.Tag == dwarf.TagVariable {
@@ -694,8 +694,8 @@
 // parseParameterOrLocal parses the entry for a function parameter or local
 // variable, which are both specified the same way. fp contains the frame
 // pointer, which is used to calculate the variable location.
-func (s *Server) parseParameterOrLocal(entry *dwarf.Entry, fp uint64) (program.LocalVar, error) {
-	var v program.LocalVar
+func (s *Server) parseParameterOrLocal(entry *dwarf.Entry, fp uint64) (debug.LocalVar, error) {
+	var v debug.LocalVar
 	v.Name, _ = entry.Val(dwarf.AttrName).(string)
 	if off, err := s.dwarfData.EntryTypeOffset(entry); err != nil {
 		return v, err
@@ -775,11 +775,11 @@
 	return false
 }
 
-func (s *Server) VarByName(req *proxyrpc.VarByNameRequest, resp *proxyrpc.VarByNameResponse) error {
+func (s *Server) VarByName(req *protocol.VarByNameRequest, resp *protocol.VarByNameResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleVarByName(req *proxyrpc.VarByNameRequest, resp *proxyrpc.VarByNameResponse) error {
+func (s *Server) handleVarByName(req *protocol.VarByNameRequest, resp *protocol.VarByNameResponse) error {
 	entry, err := s.dwarfData.LookupEntry(req.Name)
 	if err != nil {
 		return fmt.Errorf("variable %s: %s", req.Name, err)
@@ -800,11 +800,11 @@
 	return nil
 }
 
-func (s *Server) Value(req *proxyrpc.ValueRequest, resp *proxyrpc.ValueResponse) error {
+func (s *Server) Value(req *protocol.ValueRequest, resp *protocol.ValueResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleValue(req *proxyrpc.ValueRequest, resp *proxyrpc.ValueResponse) error {
+func (s *Server) handleValue(req *protocol.ValueRequest, resp *protocol.ValueResponse) error {
 	t, err := s.dwarfData.Type(dwarf.Offset(req.Var.TypeID))
 	if err != nil {
 		return err
@@ -813,11 +813,11 @@
 	return err
 }
 
-func (s *Server) MapElement(req *proxyrpc.MapElementRequest, resp *proxyrpc.MapElementResponse) error {
+func (s *Server) MapElement(req *protocol.MapElementRequest, resp *protocol.MapElementResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-func (s *Server) handleMapElement(req *proxyrpc.MapElementRequest, resp *proxyrpc.MapElementResponse) error {
+func (s *Server) handleMapElement(req *protocol.MapElementRequest, resp *protocol.MapElementResponse) error {
 	t, err := s.dwarfData.Type(dwarf.Offset(req.Map.TypeID))
 	if err != nil {
 		return err
@@ -833,8 +833,8 @@
 	fn := func(keyAddr, valAddr uint64, keyType, valType dwarf.Type) bool {
 		count++
 		if count == req.Index+1 {
-			resp.Key = program.Var{TypeID: uint64(keyType.Common().Offset), Address: keyAddr}
-			resp.Value = program.Var{TypeID: uint64(valType.Common().Offset), Address: valAddr}
+			resp.Key = debug.Var{TypeID: uint64(keyType.Common().Offset), Address: keyAddr}
+			resp.Value = debug.Var{TypeID: uint64(valType.Common().Offset), Address: valAddr}
 			return false
 		}
 		return true
@@ -849,33 +849,33 @@
 	return nil
 }
 
-func (s *Server) Goroutines(req *proxyrpc.GoroutinesRequest, resp *proxyrpc.GoroutinesResponse) error {
+func (s *Server) Goroutines(req *protocol.GoroutinesRequest, resp *protocol.GoroutinesResponse) error {
 	return s.call(s.otherc, req, resp)
 }
 
-const invalidStatus program.GoroutineStatus = 99
+const invalidStatus debug.GoroutineStatus = 99
 
 var (
-	gStatus = [...]program.GoroutineStatus{
-		0: program.Queued,  // _Gidle
-		1: program.Queued,  // _Grunnable
-		2: program.Running, // _Grunning
-		3: program.Blocked, // _Gsyscall
-		4: program.Blocked, // _Gwaiting
-		5: invalidStatus,   // _Gmoribund_unused
-		6: invalidStatus,   // _Gdead
-		7: invalidStatus,   // _Genqueue
-		8: program.Running, // _Gcopystack
+	gStatus = [...]debug.GoroutineStatus{
+		0: debug.Queued,  // _Gidle
+		1: debug.Queued,  // _Grunnable
+		2: debug.Running, // _Grunning
+		3: debug.Blocked, // _Gsyscall
+		4: debug.Blocked, // _Gwaiting
+		5: invalidStatus, // _Gmoribund_unused
+		6: invalidStatus, // _Gdead
+		7: invalidStatus, // _Genqueue
+		8: debug.Running, // _Gcopystack
 	}
-	gScanStatus = [...]program.GoroutineStatus{
-		0: invalidStatus,   // _Gscan + _Gidle
-		1: program.Queued,  // _Gscanrunnable
-		2: program.Running, // _Gscanrunning
-		3: program.Blocked, // _Gscansyscall
-		4: program.Blocked, // _Gscanwaiting
-		5: invalidStatus,   // _Gscan + _Gmoribund_unused
-		6: invalidStatus,   // _Gscan + _Gdead
-		7: program.Queued,  // _Gscanenqueue
+	gScanStatus = [...]debug.GoroutineStatus{
+		0: invalidStatus, // _Gscan + _Gidle
+		1: debug.Queued,  // _Gscanrunnable
+		2: debug.Running, // _Gscanrunning
+		3: debug.Blocked, // _Gscansyscall
+		4: debug.Blocked, // _Gscanwaiting
+		5: invalidStatus, // _Gscan + _Gmoribund_unused
+		6: invalidStatus, // _Gscan + _Gdead
+		7: debug.Queued,  // _Gscanenqueue
 	}
 	gStatusString = [...]string{
 		0: "idle",
@@ -894,7 +894,7 @@
 	}
 )
 
-func (s *Server) handleGoroutines(req *proxyrpc.GoroutinesRequest, resp *proxyrpc.GoroutinesResponse) error {
+func (s *Server) handleGoroutines(req *protocol.GoroutinesRequest, resp *protocol.GoroutinesResponse) error {
 	// Get DWARF type information for runtime.g.
 	ge, err := s.dwarfData.LookupEntry("runtime.g")
 	if err != nil {
@@ -972,7 +972,7 @@
 		if err != nil {
 			return err
 		}
-		gr := program.Goroutine{}
+		gr := debug.Goroutine{}
 
 		// Read status from the field named "atomicstatus" or "status".
 		status, err := s.peekUintStructField(gType, g, "atomicstatus")
@@ -1034,7 +1034,7 @@
 		if gopc, err := s.peekUintStructField(gType, g, "gopc"); err == nil {
 			gr.Caller = functionName(gopc)
 		}
-		if gr.Status != program.Running {
+		if gr.Status != debug.Running {
 			// TODO: running goroutines too.
 			gr.StackFrames, _ = s.goroutineStack(g)
 		}
@@ -1054,7 +1054,7 @@
 	// If we fail to read the DWARF data needed for s.goroutineStack, calling it
 	// will always return the error that occurred during initialization.
 	var err error // err is captured by the func below.
-	s.goroutineStack = func(gAddr uint64) ([]program.Frame, error) {
+	s.goroutineStack = func(gAddr uint64) ([]debug.Frame, error) {
 		return nil, err
 	}
 
@@ -1099,7 +1099,7 @@
 		}
 	}
 
-	s.goroutineStack = func(gAddr uint64) ([]program.Frame, error) {
+	s.goroutineStack = func(gAddr uint64) ([]debug.Frame, error) {
 		schedPC, err := s.peekUint(gAddr+schedPCOffset, schedPCByteSize)
 		if err != nil {
 			return nil, err
diff --git a/ogle/program/server/value.go b/server/value.go
similarity index 91%
rename from ogle/program/server/value.go
rename to server/value.go
index 2b5c1c6..0fef7fe 100644
--- a/ogle/program/server/value.go
+++ b/server/value.go
@@ -6,12 +6,13 @@
 
 import (
 	"fmt"
+
+	"golang.org/x/debug"
 	"golang.org/x/debug/dwarf"
-	"golang.org/x/debug/ogle/program"
 )
 
 // value peeks the program's memory at the given address, parsing it as a value of type t.
-func (s *Server) value(t dwarf.Type, addr uint64) (program.Value, error) {
+func (s *Server) value(t dwarf.Type, addr uint64) (debug.Value, error) {
 	// readBasic reads the memory for a basic type of size n bytes.
 	readBasic := func(n int64) ([]byte, error) {
 		switch n {
@@ -114,7 +115,7 @@
 		if err != nil {
 			return nil, fmt.Errorf("reading pointer: %s", err)
 		}
-		return program.Pointer{
+		return debug.Pointer{
 			TypeID:  uint64(t.Type.Common().Offset),
 			Address: uint64(s.arch.Uintptr(buf)),
 		}, nil
@@ -135,8 +136,8 @@
 			return nil, fmt.Errorf("slice's capacity %d is less than its length %d", capacity, length)
 		}
 
-		return program.Slice{
-			program.Array{
+		return debug.Slice{
+			debug.Array{
 				ElementTypeID: uint64(t.ElemType.Common().Offset),
 				Address:       uint64(ptr),
 				Length:        length,
@@ -150,24 +151,24 @@
 		if stride%8 != 0 {
 			return nil, fmt.Errorf("array is not byte-aligned")
 		}
-		return program.Array{
+		return debug.Array{
 			ElementTypeID: uint64(t.Type.Common().Offset),
 			Address:       uint64(addr),
 			Length:        uint64(length),
 			StrideBits:    uint64(stride),
 		}, nil
 	case *dwarf.StructType:
-		fields := make([]program.StructField, len(t.Field))
+		fields := make([]debug.StructField, len(t.Field))
 		for i, field := range t.Field {
-			fields[i] = program.StructField{
+			fields[i] = debug.StructField{
 				Name: field.Name,
-				Var: program.Var{
+				Var: debug.Var{
 					TypeID:  uint64(field.Type.Common().Offset),
 					Address: uint64(addr) + uint64(field.ByteOffset),
 				},
 			}
 		}
-		return program.Struct{fields}, nil
+		return debug.Struct{fields}, nil
 	case *dwarf.TypedefType:
 		return s.value(t.Type, addr)
 	case *dwarf.MapType:
@@ -175,7 +176,7 @@
 		if err != nil {
 			return nil, err
 		}
-		return program.Map{
+		return debug.Map{
 			TypeID:  uint64(t.Common().Offset),
 			Address: addr,
 			Length:  length,
@@ -200,7 +201,7 @@
 		if err := s.peekBytes(ptr, tmp); err != nil {
 			return nil, fmt.Errorf("reading string contents: %s", err)
 		}
-		return program.String{Length: length, String: string(tmp)}, nil
+		return debug.String{Length: length, String: string(tmp)}, nil
 	case *dwarf.ChanType:
 		pt, ok := t.TypedefType.Type.(*dwarf.PtrType)
 		if !ok {
@@ -217,7 +218,7 @@
 		}
 		if a == 0 {
 			// This channel is nil.
-			return program.Channel{
+			return debug.Channel{
 				ElementTypeID: uint64(t.ElemType.Common().Offset),
 				Address:       0,
 				Buffer:        0,
@@ -244,7 +245,7 @@
 		if err != nil {
 			return nil, fmt.Errorf("reading channel buffer index: %s", err)
 		}
-		return program.Channel{
+		return debug.Channel{
 			ElementTypeID: uint64(t.ElemType.Common().Offset),
 			Address:       a,
 			Buffer:        buf,
@@ -258,9 +259,9 @@
 		if err != nil {
 			return nil, fmt.Errorf("reading func: %s", err)
 		}
-		return program.Func{Address: a}, nil
+		return debug.Func{Address: a}, nil
 	case *dwarf.InterfaceType:
-		return program.Interface{}, nil
+		return debug.Interface{}, nil
 		// TODO: more types
 	}
 	return nil, fmt.Errorf("Unsupported type %T", t)
diff --git a/ogle/demo/ogler/ogler_test.go b/tests/peek/peek_test.go
similarity index 73%
rename from ogle/demo/ogler/ogler_test.go
rename to tests/peek/peek_test.go
index 729fa75..8d00a93 100644
--- a/ogle/demo/ogler/ogler_test.go
+++ b/tests/peek/peek_test.go
@@ -2,10 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Demo program that starts another program and calls Ogle library functions
-// to debug it.
-
-package ogler
+package peek_test
 
 import (
 	"fmt"
@@ -15,9 +12,9 @@
 	"reflect"
 	"testing"
 
-	"golang.org/x/debug/ogle/program"
-	"golang.org/x/debug/ogle/program/client"
-	"golang.org/x/debug/ogle/program/local"
+	"golang.org/x/debug"
+	"golang.org/x/debug/local"
+	"golang.org/x/debug/remote"
 )
 
 var expectedVarValues = map[string]interface{}{
@@ -87,53 +84,53 @@
 	`main.Z_unsafe_pointer_nil`:  `0x0`,
 }
 
-// expectedEvaluate contains expected results of the program.Evaluate function.
+// expectedEvaluate contains expected results of the debug.Evaluate function.
 // A nil value indicates that an error is expected.
-var expectedEvaluate = map[string]program.Value{
+var expectedEvaluate = map[string]debug.Value{
 	`x`:                                                          int16(42),
-	`local_array`:                                                program.Array{42, 42, 5, 8},
+	`local_array`:                                                debug.Array{42, 42, 5, 8},
 	`local_bool_false`:                                           false,
 	`local_bool_true`:                                            true,
-	`local_channel`:                                              program.Channel{42, 42, 42, 0, 0, 2, 0},
-	`local_channel_buffered`:                                     program.Channel{42, 42, 42, 6, 10, 2, 8},
-	`local_channel_nil`:                                          program.Channel{42, 0, 0, 0, 0, 2, 0},
+	`local_channel`:                                              debug.Channel{42, 42, 42, 0, 0, 2, 0},
+	`local_channel_buffered`:                                     debug.Channel{42, 42, 42, 6, 10, 2, 8},
+	`local_channel_nil`:                                          debug.Channel{42, 0, 0, 0, 0, 2, 0},
 	`local_complex128`:                                           complex128(1.987654321 - 2.987654321i),
 	`local_complex64`:                                            complex64(1.54321 + 2.54321i),
 	`local_float32`:                                              float32(1.54321),
 	`local_float64`:                                              float64(1.987654321),
-	`local_func_int8_r_int8`:                                     program.Func{42},
-	`local_func_int8_r_pint8`:                                    program.Func{42},
-	`local_func_bar`:                                             program.Func{42},
-	`local_func_nil`:                                             program.Func{0},
+	`local_func_int8_r_int8`:                                     debug.Func{42},
+	`local_func_int8_r_pint8`:                                    debug.Func{42},
+	`local_func_bar`:                                             debug.Func{42},
+	`local_func_nil`:                                             debug.Func{0},
 	`local_int`:                                                  -21,
 	`local_int16`:                                                int16(-32321),
 	`local_int32`:                                                int32(-1987654321),
 	`local_int64`:                                                int64(-9012345678987654321),
 	`local_int8`:                                                 int8(-121),
 	`local_int_typedef`:                                          int16(88),
-	`local_interface`:                                            program.Interface{},
-	`local_interface_nil`:                                        program.Interface{},
-	`local_interface_typed_nil`:                                  program.Interface{},
-	`local_map`:                                                  program.Map{42, 42, 1},
-	`local_map_2`:                                                program.Map{42, 42, 1},
-	`local_map_3`:                                                program.Map{42, 42, 2},
-	`local_map_empty`:                                            program.Map{42, 42, 0},
-	`local_map_nil`:                                              program.Map{42, 42, 0},
-	`local_pointer`:                                              program.Pointer{42, 42},
-	`local_pointer_nil`:                                          program.Pointer{42, 0},
-	`local_slice`:                                                program.Slice{program.Array{42, 42, 5, 8}, 5},
-	`local_slice_2`:                                              program.Slice{program.Array{42, 42, 2, 8}, 5},
-	`local_slice_nil`:                                            program.Slice{program.Array{42, 0, 0, 8}, 0},
-	`local_string`:                                               program.String{12, `I'm a string`},
-	`local_struct`:                                               program.Struct{[]program.StructField{{"a", program.Var{}}, {"b", program.Var{}}}},
+	`local_interface`:                                            debug.Interface{},
+	`local_interface_nil`:                                        debug.Interface{},
+	`local_interface_typed_nil`:                                  debug.Interface{},
+	`local_map`:                                                  debug.Map{42, 42, 1},
+	`local_map_2`:                                                debug.Map{42, 42, 1},
+	`local_map_3`:                                                debug.Map{42, 42, 2},
+	`local_map_empty`:                                            debug.Map{42, 42, 0},
+	`local_map_nil`:                                              debug.Map{42, 42, 0},
+	`local_pointer`:                                              debug.Pointer{42, 42},
+	`local_pointer_nil`:                                          debug.Pointer{42, 0},
+	`local_slice`:                                                debug.Slice{debug.Array{42, 42, 5, 8}, 5},
+	`local_slice_2`:                                              debug.Slice{debug.Array{42, 42, 2, 8}, 5},
+	`local_slice_nil`:                                            debug.Slice{debug.Array{42, 0, 0, 8}, 0},
+	`local_string`:                                               debug.String{12, `I'm a string`},
+	`local_struct`:                                               debug.Struct{[]debug.StructField{{"a", debug.Var{}}, {"b", debug.Var{}}}},
 	`local_uint`:                                                 uint(21),
 	`local_uint16`:                                               uint16(54321),
 	`local_uint32`:                                               uint32(3217654321),
 	`local_uint64`:                                               uint64(12345678900987654321),
 	`local_uint8`:                                                uint8(231),
 	`local_uintptr`:                                              uint(21),
-	`local_unsafe_pointer`:                                       program.Pointer{0, 42},
-	`local_unsafe_pointer_nil`:                                   program.Pointer{0, 0},
+	`local_unsafe_pointer`:                                       debug.Pointer{0, 42},
+	`local_unsafe_pointer_nil`:                                   debug.Pointer{0, 0},
 	`x + 5`:                                                      int16(47),
 	`x - 5`:                                                      int16(37),
 	`x / 5`:                                                      int16(8),
@@ -156,9 +153,9 @@
 	`1e5`:                                                        100000.0,
 	`0x42`:                                                       66,
 	`'c'`:                                                        'c',
-	`"de"`:                                                       program.String{2, `de`},
-	"`ef`":                                                       program.String{2, `ef`},
-	`"de" + "fg"`:                                                program.String{4, `defg`},
+	`"de"`:                                                       debug.String{2, `de`},
+	"`ef`":                                                       debug.String{2, `ef`},
+	`"de" + "fg"`:                                                debug.String{4, `defg`},
 	`/* comment */ -5`:                                           -5,
 	`false`:                                                      false,
 	`true`:                                                       true,
@@ -182,16 +179,16 @@
 	`(6 + 8i) * (1 + 1i)`:                                        -2 + 14i,
 	`(6 + 8i) * (6 - 8i)`:                                        complex128(100),
 	`(6 + 8i) / (3 + 4i)`:                                        complex128(2),
-	`local_string + "!"`:                                         program.String{13, `I'm a string!`},
-	`*local_pointer`:                                             program.Struct{[]program.StructField{{"a", program.Var{}}, {"b", program.Var{}}}},
-	`&local_int16`:                                               program.Pointer{42, 42},
+	`local_string + "!"`:                                         debug.String{13, `I'm a string!`},
+	`*local_pointer`:                                             debug.Struct{[]debug.StructField{{"a", debug.Var{}}, {"b", debug.Var{}}}},
+	`&local_int16`:                                               debug.Pointer{42, 42},
 	`*&local_int16`:                                              int16(-32321),
 	`*&*&*&*&local_int16`:                                        int16(-32321),
 	`local_array[2]`:                                             int8(3),
 	`local_slice[1]`:                                             uint8(108),
 	`local_slice_2[1]`:                                           int8(121),
-	`&local_array[1]`:                                            program.Pointer{42, 42},
-	`&local_slice[1]`:                                            program.Pointer{42, 42},
+	`&local_array[1]`:                                            debug.Pointer{42, 42},
+	`&local_slice[1]`:                                            debug.Pointer{42, 42},
 	`local_map[-21]`:                                             float32(3.54321),
 	`local_map[+21]`:                                             float32(0),
 	`local_map_3[1024]`:                                          int8(1),
@@ -202,78 +199,78 @@
 	`"hello"[2]`:                                                 uint8('l'),
 	`local_array[1:3][1]`:                                        int8(3),
 	`local_array[0:4][2:3][0]`:                                   int8(3),
-	`local_array[:]`:                                             program.Slice{program.Array{42, 42, 5, 8}, 5},
-	`local_array[:2]`:                                            program.Slice{program.Array{42, 42, 2, 8}, 5},
-	`local_array[2:]`:                                            program.Slice{program.Array{42, 42, 3, 8}, 3},
-	`local_array[1:3]`:                                           program.Slice{program.Array{42, 42, 2, 8}, 4},
-	`local_array[:3:4]`:                                          program.Slice{program.Array{42, 42, 3, 8}, 4},
-	`local_array[1:3:4]`:                                         program.Slice{program.Array{42, 42, 2, 8}, 3},
-	`local_array[1:][1:][1:]`:                                    program.Slice{program.Array{42, 42, 2, 8}, 2},
-	`(&local_array)[:]`:                                          program.Slice{program.Array{42, 42, 5, 8}, 5},
-	`(&local_array)[:2]`:                                         program.Slice{program.Array{42, 42, 2, 8}, 5},
-	`(&local_array)[2:]`:                                         program.Slice{program.Array{42, 42, 3, 8}, 3},
-	`(&local_array)[1:3]`:                                        program.Slice{program.Array{42, 42, 2, 8}, 4},
-	`(&local_array)[:3:4]`:                                       program.Slice{program.Array{42, 42, 3, 8}, 4},
-	`(&local_array)[1:3:4]`:                                      program.Slice{program.Array{42, 42, 2, 8}, 3},
+	`local_array[:]`:                                             debug.Slice{debug.Array{42, 42, 5, 8}, 5},
+	`local_array[:2]`:                                            debug.Slice{debug.Array{42, 42, 2, 8}, 5},
+	`local_array[2:]`:                                            debug.Slice{debug.Array{42, 42, 3, 8}, 3},
+	`local_array[1:3]`:                                           debug.Slice{debug.Array{42, 42, 2, 8}, 4},
+	`local_array[:3:4]`:                                          debug.Slice{debug.Array{42, 42, 3, 8}, 4},
+	`local_array[1:3:4]`:                                         debug.Slice{debug.Array{42, 42, 2, 8}, 3},
+	`local_array[1:][1:][1:]`:                                    debug.Slice{debug.Array{42, 42, 2, 8}, 2},
+	`(&local_array)[:]`:                                          debug.Slice{debug.Array{42, 42, 5, 8}, 5},
+	`(&local_array)[:2]`:                                         debug.Slice{debug.Array{42, 42, 2, 8}, 5},
+	`(&local_array)[2:]`:                                         debug.Slice{debug.Array{42, 42, 3, 8}, 3},
+	`(&local_array)[1:3]`:                                        debug.Slice{debug.Array{42, 42, 2, 8}, 4},
+	`(&local_array)[:3:4]`:                                       debug.Slice{debug.Array{42, 42, 3, 8}, 4},
+	`(&local_array)[1:3:4]`:                                      debug.Slice{debug.Array{42, 42, 2, 8}, 3},
 	`local_slice[1:5][0:3][1]`:                                   uint8('i'),
-	`local_slice[:]`:                                             program.Slice{program.Array{42, 42, 5, 8}, 5},
-	`local_slice[:2]`:                                            program.Slice{program.Array{42, 42, 2, 8}, 5},
-	`local_slice[2:]`:                                            program.Slice{program.Array{42, 42, 3, 8}, 3},
-	`local_slice[1:3]`:                                           program.Slice{program.Array{42, 42, 2, 8}, 4},
-	`local_slice[:3:4]`:                                          program.Slice{program.Array{42, 42, 3, 8}, 4},
-	`local_slice[1:3:4]`:                                         program.Slice{program.Array{42, 42, 2, 8}, 3},
+	`local_slice[:]`:                                             debug.Slice{debug.Array{42, 42, 5, 8}, 5},
+	`local_slice[:2]`:                                            debug.Slice{debug.Array{42, 42, 2, 8}, 5},
+	`local_slice[2:]`:                                            debug.Slice{debug.Array{42, 42, 3, 8}, 3},
+	`local_slice[1:3]`:                                           debug.Slice{debug.Array{42, 42, 2, 8}, 4},
+	`local_slice[:3:4]`:                                          debug.Slice{debug.Array{42, 42, 3, 8}, 4},
+	`local_slice[1:3:4]`:                                         debug.Slice{debug.Array{42, 42, 2, 8}, 3},
 	`local_struct.a`:                                             21,
 	`(&local_struct).a`:                                          21,
 	`(*local_pointer).a`:                                         21,
 	`(&*local_pointer).a`:                                        21,
-	`(*local_pointer).b`:                                         program.String{2, `hi`},
+	`(*local_pointer).b`:                                         debug.String{2, `hi`},
 	`local_pointer.a`:                                            21,
-	`local_pointer.b`:                                            program.String{2, `hi`},
-	`lookup("main.Z_array")`:                                     program.Array{42, 42, 5, 8},
-	`lookup("main.Z_array_empty")`:                               program.Array{42, 42, 0, 8},
+	`local_pointer.b`:                                            debug.String{2, `hi`},
+	`lookup("main.Z_array")`:                                     debug.Array{42, 42, 5, 8},
+	`lookup("main.Z_array_empty")`:                               debug.Array{42, 42, 0, 8},
 	`lookup("main.Z_bool_false")`:                                false,
 	`lookup("main.Z_bool_true")`:                                 true,
-	`lookup("main.Z_channel")`:                                   program.Channel{42, 42, 42, 0, 0, 2, 0},
-	`lookup("main.Z_channel_buffered")`:                          program.Channel{42, 42, 42, 6, 10, 2, 8},
-	`lookup("main.Z_channel_nil")`:                               program.Channel{42, 0, 0, 0, 0, 2, 0},
-	`lookup("main.Z_array_of_empties")`:                          program.Array{42, 42, 2, 0},
+	`lookup("main.Z_channel")`:                                   debug.Channel{42, 42, 42, 0, 0, 2, 0},
+	`lookup("main.Z_channel_buffered")`:                          debug.Channel{42, 42, 42, 6, 10, 2, 8},
+	`lookup("main.Z_channel_nil")`:                               debug.Channel{42, 0, 0, 0, 0, 2, 0},
+	`lookup("main.Z_array_of_empties")`:                          debug.Array{42, 42, 2, 0},
 	`lookup("main.Z_complex128")`:                                complex128(1.987654321 - 2.987654321i),
 	`lookup("main.Z_complex64")`:                                 complex64(1.54321 + 2.54321i),
 	`lookup("main.Z_float32")`:                                   float32(1.54321),
 	`lookup("main.Z_float64")`:                                   float64(1.987654321),
-	`lookup("main.Z_func_int8_r_int8")`:                          program.Func{42},
-	`lookup("main.Z_func_int8_r_pint8")`:                         program.Func{42},
-	`lookup("main.Z_func_bar")`:                                  program.Func{42},
-	`lookup("main.Z_func_nil")`:                                  program.Func{0},
+	`lookup("main.Z_func_int8_r_int8")`:                          debug.Func{42},
+	`lookup("main.Z_func_int8_r_pint8")`:                         debug.Func{42},
+	`lookup("main.Z_func_bar")`:                                  debug.Func{42},
+	`lookup("main.Z_func_nil")`:                                  debug.Func{0},
 	`lookup("main.Z_int")`:                                       -21,
 	`lookup("main.Z_int16")`:                                     int16(-32321),
 	`lookup("main.Z_int32")`:                                     int32(-1987654321),
 	`lookup("main.Z_int64")`:                                     int64(-9012345678987654321),
 	`lookup("main.Z_int8")`:                                      int8(-121),
 	`lookup("main.Z_int_typedef")`:                               int16(88),
-	`lookup("main.Z_interface")`:                                 program.Interface{},
-	`lookup("main.Z_interface_nil")`:                             program.Interface{},
-	`lookup("main.Z_interface_typed_nil")`:                       program.Interface{},
-	`lookup("main.Z_map")`:                                       program.Map{42, 42, 1},
-	`lookup("main.Z_map_2")`:                                     program.Map{42, 42, 1},
-	`lookup("main.Z_map_3")`:                                     program.Map{42, 42, 2},
-	`lookup("main.Z_map_empty")`:                                 program.Map{42, 42, 0},
-	`lookup("main.Z_map_nil")`:                                   program.Map{42, 42, 0},
-	`lookup("main.Z_pointer")`:                                   program.Pointer{42, 42},
-	`lookup("main.Z_pointer_nil")`:                               program.Pointer{42, 0},
-	`lookup("main.Z_slice")`:                                     program.Slice{program.Array{42, 42, 5, 8}, 5},
-	`lookup("main.Z_slice_2")`:                                   program.Slice{program.Array{42, 42, 2, 8}, 5},
-	`lookup("main.Z_slice_nil")`:                                 program.Slice{program.Array{42, 0, 0, 8}, 0},
-	`lookup("main.Z_string")`:                                    program.String{12, `I'm a string`},
-	`lookup("main.Z_struct")`:                                    program.Struct{[]program.StructField{{"a", program.Var{}}, {"b", program.Var{}}}},
+	`lookup("main.Z_interface")`:                                 debug.Interface{},
+	`lookup("main.Z_interface_nil")`:                             debug.Interface{},
+	`lookup("main.Z_interface_typed_nil")`:                       debug.Interface{},
+	`lookup("main.Z_map")`:                                       debug.Map{42, 42, 1},
+	`lookup("main.Z_map_2")`:                                     debug.Map{42, 42, 1},
+	`lookup("main.Z_map_3")`:                                     debug.Map{42, 42, 2},
+	`lookup("main.Z_map_empty")`:                                 debug.Map{42, 42, 0},
+	`lookup("main.Z_map_nil")`:                                   debug.Map{42, 42, 0},
+	`lookup("main.Z_pointer")`:                                   debug.Pointer{42, 42},
+	`lookup("main.Z_pointer_nil")`:                               debug.Pointer{42, 0},
+	`lookup("main.Z_slice")`:                                     debug.Slice{debug.Array{42, 42, 5, 8}, 5},
+	`lookup("main.Z_slice_2")`:                                   debug.Slice{debug.Array{42, 42, 2, 8}, 5},
+	`lookup("main.Z_slice_nil")`:                                 debug.Slice{debug.Array{42, 0, 0, 8}, 0},
+	`lookup("main.Z_string")`:                                    debug.String{12, `I'm a string`},
+	`lookup("main.Z_struct")`:                                    debug.Struct{[]debug.StructField{{"a", debug.Var{}}, {"b", debug.Var{}}}},
 	`lookup("main.Z_uint")`:                                      uint(21),
 	`lookup("main.Z_uint16")`:                                    uint16(54321),
 	`lookup("main.Z_uint32")`:                                    uint32(3217654321),
 	`lookup("main.Z_uint64")`:                                    uint64(12345678900987654321),
 	`lookup("main.Z_uint8")`:                                     uint8(231),
 	`lookup("main.Z_uintptr")`:                                   uint(21),
-	`lookup("main.Z_unsafe_pointer")`:                            program.Pointer{0, 42},
-	`lookup("main.Z_unsafe_pointer_nil")`:                        program.Pointer{0, 0},
+	`lookup("main.Z_unsafe_pointer")`:                            debug.Pointer{0, 42},
+	`lookup("main.Z_unsafe_pointer_nil")`:                        debug.Pointer{0, 0},
 	`lookup("main.Z_int") + lookup("main.Z_int")`:                -42,
 	`lookup("main.Z_int16") < 0`:                                 true,
 	`lookup("main.Z_uint32") + lookup("main.Z_uint32")`:          uint32(2140341346),
@@ -285,7 +282,7 @@
 	`lookup("main.Z_array")[2]`:                                  int8(3),
 	`lookup("main.Z_array")[1:3][1]`:                             int8(3),
 	`lookup("main.Z_array")[0:4][2:3][0]`:                        int8(3),
-	`lookup("main.Z_array_of_empties")[0]`:                       program.Struct{},
+	`lookup("main.Z_array_of_empties")[0]`:                       debug.Struct{},
 	`lookup("main.Z_complex128") * 10.0`:                         complex128(19.87654321 - 29.87654321i),
 	`lookup("main.Z_complex64") * 0.1`:                           complex64(0.154321 + 0.254321i),
 	`lookup("main.Z_float32") * 10.0`:                            float32(15.4321),
@@ -301,9 +298,9 @@
 	`lookup("main.Z_slice")[1]`:                                  uint8(108),
 	`lookup("main.Z_slice_2")[1]`:                                int8(121),
 	`lookup("main.Z_slice")[1:5][0:3][1]`:                        uint8('i'),
-	`lookup("main.Z_array")[1:3:4]`:                              program.Slice{program.Array{42, 42, 2, 8}, 3},
-	`(&lookup("main.Z_array"))[1:3:4]`:                           program.Slice{program.Array{42, 42, 2, 8}, 3},
-	`lookup("main.Z_string") + "!"`:                              program.String{13, `I'm a string!`},
+	`lookup("main.Z_array")[1:3:4]`:                              debug.Slice{debug.Array{42, 42, 2, 8}, 3},
+	`(&lookup("main.Z_array"))[1:3:4]`:                           debug.Slice{debug.Array{42, 42, 2, 8}, 3},
+	`lookup("main.Z_string") + "!"`:                              debug.String{13, `I'm a string!`},
 	`lookup("main.Z_struct").a`:                                  21,
 	`(&lookup("main.Z_struct")).a`:                               21,
 	`lookup("main.Z_uint")/10`:                                   uint(2),
@@ -314,16 +311,16 @@
 	`lookup("main.Z_pointer").a`:                                 21,
 	`(*lookup("main.Z_pointer")).a`:                              21,
 	`(&*lookup("main.Z_pointer")).a`:                             21,
-	`lookup("main.Z_pointer").b`:                                 program.String{2, `hi`},
-	`(*lookup("main.Z_pointer")).b`:                              program.String{2, `hi`},
-	`(&*lookup("main.Z_pointer")).b`:                             program.String{2, `hi`},
+	`lookup("main.Z_pointer").b`:                                 debug.String{2, `hi`},
+	`(*lookup("main.Z_pointer")).b`:                              debug.String{2, `hi`},
+	`(&*lookup("main.Z_pointer")).b`:                             debug.String{2, `hi`},
 	`lookup("main.Z_map_nil")[32]`:                               float32(0),
-	`&lookup("main.Z_int16")`:                                    program.Pointer{42, 42},
-	`&lookup("main.Z_array")[1]`:                                 program.Pointer{42, 42},
-	`&lookup("main.Z_slice")[1]`:                                 program.Pointer{42, 42},
+	`&lookup("main.Z_int16")`:                                    debug.Pointer{42, 42},
+	`&lookup("main.Z_array")[1]`:                                 debug.Pointer{42, 42},
+	`&lookup("main.Z_slice")[1]`:                                 debug.Pointer{42, 42},
 	`*&lookup("main.Z_int16")`:                                   int16(-32321),
 	`*&*&*&*&lookup("main.Z_int16")`:                             int16(-32321),
-	`lookup("time.Local")`:                                       program.Pointer{42, 42},
+	`lookup("time.Local")`:                                       debug.Pointer{42, 42},
 	`5 + false`:                                                  nil,
 	``:                                                           nil,
 	`x + ""`:                                                     nil,
@@ -400,10 +397,10 @@
 }
 
 const (
-	proxySrc     = "golang.org/x/debug/ogle/cmd/ogleproxy"
-	proxyBinary  = "./ogleproxy"
-	traceeSrc    = "golang.org/x/debug/ogle/demo/tracee"
-	traceeBinary = "./tracee"
+	proxySrc     = "golang.org/x/debug/cmd/debugproxy"
+	proxyBinary  = "./debugproxy.out"
+	traceeSrc    = "golang.org/x/debug/tests/peek/testdata"
+	traceeBinary = "./tracee.out"
 )
 
 func TestMain(m *testing.M) {
@@ -415,7 +412,7 @@
 		fmt.Println(err)
 		return 1
 	}
-	client.OgleproxyCmd = proxyBinary
+	remote.DebugproxyCmd = proxyBinary
 	defer os.Remove(proxyBinary)
 	if err := run("go", "build", "-o", traceeBinary, traceeSrc); err != nil {
 		fmt.Println(err)
@@ -434,14 +431,14 @@
 }
 
 func TestRemoteProgram(t *testing.T) {
-	prog, err := client.New("localhost", traceeBinary)
+	prog, err := remote.New("localhost", traceeBinary)
 	if err != nil {
-		t.Fatal("client.New:", err)
+		t.Fatal("remote.New:", err)
 	}
 	testProgram(t, prog)
 }
 
-func testProgram(t *testing.T, prog program.Program) {
+func testProgram(t *testing.T, prog debug.Program) {
 	_, err := prog.Run("some", "arguments")
 	if err != nil {
 		log.Fatalf("Run: %v", err)
@@ -595,8 +592,8 @@
 			if v != val {
 				t.Errorf("got Evaluate(%s) = %T(%v), expected %T(%v)", k, val, val, v, v)
 			}
-		case program.Array:
-			val := val.(program.Array)
+		case debug.Array:
+			val := val.(debug.Array)
 			if v.ElementTypeID == 0 && val.ElementTypeID != 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected zero ElementTypeID", k, val)
 			}
@@ -609,8 +606,8 @@
 			if v.Address != 0 && val.Address == 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected non-zero Address", k, val)
 			}
-		case program.Slice:
-			val := val.(program.Slice)
+		case debug.Slice:
+			val := val.(debug.Slice)
 			if v.ElementTypeID == 0 && val.ElementTypeID != 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected zero ElementTypeID", k, val)
 			}
@@ -623,8 +620,8 @@
 			if v.Address != 0 && val.Address == 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected non-zero Address", k, val)
 			}
-		case program.Map:
-			val := val.(program.Map)
+		case debug.Map:
+			val := val.(debug.Map)
 			if v.TypeID == 0 && val.TypeID != 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected zero TypeID", k, val)
 			}
@@ -637,8 +634,8 @@
 			if v.Address != 0 && val.Address == 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected non-zero Address", k, val)
 			}
-		case program.Pointer:
-			val := val.(program.Pointer)
+		case debug.Pointer:
+			val := val.(debug.Pointer)
 			if v.TypeID == 0 && val.TypeID != 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected zero TypeID", k, val)
 			}
@@ -651,8 +648,8 @@
 			if v.Address != 0 && val.Address == 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected non-zero Address", k, val)
 			}
-		case program.Channel:
-			val := val.(program.Channel)
+		case debug.Channel:
+			val := val.(debug.Channel)
 			if v.ElementTypeID == 0 && val.ElementTypeID != 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected zero ElementTypeID", k, val)
 			}
@@ -671,8 +668,8 @@
 			if v.Buffer != 0 && val.Buffer == 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected non-zero Buffer", k, val)
 			}
-		case program.Struct:
-			val := val.(program.Struct)
+		case debug.Struct:
+			val := val.(debug.Struct)
 			if len(v.Fields) != len(val.Fields) {
 				t.Errorf("got Evaluate(%s) = %T(%v), expected %T(%v)", k, val, val, v, v)
 				break
@@ -685,8 +682,8 @@
 					break
 				}
 			}
-		case program.Func:
-			val := val.(program.Func)
+		case debug.Func:
+			val := val.(debug.Func)
 			if v.Address == 0 && val.Address != 0 {
 				t.Errorf("got Evaluate(%s) = %+v, expected zero Address", k, val)
 			}
@@ -729,9 +726,9 @@
 	if err != nil {
 		t.Fatalf("Evaluate: %s", err)
 	}
-	s, ok := val.(program.Struct)
+	s, ok := val.(debug.Struct)
 	if !ok {
-		t.Fatalf("got Evaluate(`local_struct`) = %T(%v), expected program.Struct", val, val)
+		t.Fatalf("got Evaluate(`local_struct`) = %T(%v), expected debug.Struct", val, val)
 	}
 	// Check the values of its fields.
 	if len(s.Fields) != 2 {
@@ -744,7 +741,7 @@
 	}
 	if v1, err := prog.Value(s.Fields[1].Var); err != nil {
 		t.Errorf("Value: %s", err)
-	} else if v1 != (program.String{2, "hi"}) {
+	} else if v1 != (debug.String{2, "hi"}) {
 		t.Errorf("Value: got %T(%v), expected `hi`", v1, v1)
 	}
 
@@ -791,7 +788,7 @@
 	if _, err = prog.VarByName("not a real name"); err == nil {
 		t.Error("VarByName for invalid name: expected error")
 	}
-	if _, err = prog.Value(program.Var{}); err == nil {
+	if _, err = prog.Value(debug.Var{}); err == nil {
 		t.Error("value of invalid var: expected error")
 	}
 	if v, err := prog.VarByName("main.Z_int16"); err != nil {
@@ -808,7 +805,7 @@
 	// checkValue tests that we can get a Var for a variable with the given name,
 	// that we can then get the value of that Var, and that calling fn for that
 	// value succeeds.
-	checkValue := func(name string, fn func(val program.Value) error) {
+	checkValue := func(name string, fn func(val debug.Value) error) {
 		if v, err := prog.VarByName(name); err != nil {
 			t.Errorf("VarByName(%s): %s", name, err)
 		} else if val, err := prog.Value(v); err != nil {
@@ -818,7 +815,7 @@
 		}
 	}
 
-	checkValue("main.Z_uintptr", func(val program.Value) error {
+	checkValue("main.Z_uintptr", func(val debug.Value) error {
 		if val != uint32(21) && val != uint64(21) {
 			// Z_uintptr should be an unsigned integer with size equal to the debugged
 			// program's address size.
@@ -827,29 +824,29 @@
 		return nil
 	})
 
-	checkValue("main.Z_int", func(val program.Value) error {
+	checkValue("main.Z_int", func(val debug.Value) error {
 		if val != int32(-21) && val != int64(-21) {
 			return fmt.Errorf("got %T(%v) want -21", val, val)
 		}
 		return nil
 	})
 
-	checkValue("main.Z_uint", func(val program.Value) error {
+	checkValue("main.Z_uint", func(val debug.Value) error {
 		if val != uint32(21) && val != uint64(21) {
 			return fmt.Errorf("got %T(%v) want 21", val, val)
 		}
 		return nil
 	})
 
-	checkValue("main.Z_pointer", func(val program.Value) error {
-		if _, ok := val.(program.Pointer); !ok {
+	checkValue("main.Z_pointer", func(val debug.Value) error {
+		if _, ok := val.(debug.Pointer); !ok {
 			return fmt.Errorf("got %T(%v) expected Pointer", val, val)
 		}
 		return nil
 	})
 
-	checkValue("main.Z_pointer_nil", func(val program.Value) error {
-		if p, ok := val.(program.Pointer); !ok {
+	checkValue("main.Z_pointer_nil", func(val debug.Value) error {
+		if p, ok := val.(debug.Pointer); !ok {
 			return fmt.Errorf("got %T(%v) expected Pointer", val, val)
 		} else if p.Address != 0 {
 			return fmt.Errorf("got %T(%v) expected nil pointer", val, val)
@@ -857,8 +854,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_array", func(val program.Value) error {
-		a, ok := val.(program.Array)
+	checkValue("main.Z_array", func(val debug.Value) error {
+		a, ok := val.(debug.Array)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Array", val, val)
 		}
@@ -876,8 +873,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_slice", func(val program.Value) error {
-		s, ok := val.(program.Slice)
+	checkValue("main.Z_slice", func(val debug.Value) error {
+		s, ok := val.(debug.Slice)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Slice", val, val)
 		}
@@ -895,8 +892,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_map_empty", func(val program.Value) error {
-		m, ok := val.(program.Map)
+	checkValue("main.Z_map_empty", func(val debug.Value) error {
+		m, ok := val.(debug.Map)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Map", val, val)
 		}
@@ -906,8 +903,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_map_nil", func(val program.Value) error {
-		m, ok := val.(program.Map)
+	checkValue("main.Z_map_nil", func(val debug.Value) error {
+		m, ok := val.(debug.Map)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Map", val, val)
 		}
@@ -917,8 +914,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_map_3", func(val program.Value) error {
-		m, ok := val.(program.Map)
+	checkValue("main.Z_map_3", func(val debug.Value) error {
+		m, ok := val.(debug.Map)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Map", val, val)
 		}
@@ -962,8 +959,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_string", func(val program.Value) error {
-		s, ok := val.(program.String)
+	checkValue("main.Z_string", func(val debug.Value) error {
+		s, ok := val.(debug.String)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected String", val, val)
 		}
@@ -977,8 +974,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_channel", func(val program.Value) error {
-		c, ok := val.(program.Channel)
+	checkValue("main.Z_channel", func(val debug.Value) error {
+		c, ok := val.(debug.Channel)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Channel", val, val)
 		}
@@ -994,8 +991,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_channel_2", func(val program.Value) error {
-		c, ok := val.(program.Channel)
+	checkValue("main.Z_channel_2", func(val debug.Value) error {
+		c, ok := val.(debug.Channel)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Channel", val, val)
 		}
@@ -1011,8 +1008,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_channel_nil", func(val program.Value) error {
-		c, ok := val.(program.Channel)
+	checkValue("main.Z_channel_nil", func(val debug.Value) error {
+		c, ok := val.(debug.Channel)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Channel", val, val)
 		}
@@ -1028,8 +1025,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_channel_buffered", func(val program.Value) error {
-		c, ok := val.(program.Channel)
+	checkValue("main.Z_channel_buffered", func(val debug.Value) error {
+		c, ok := val.(debug.Channel)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Channel", val, val)
 		}
@@ -1060,8 +1057,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_func_bar", func(val program.Value) error {
-		f, ok := val.(program.Func)
+	checkValue("main.Z_func_bar", func(val debug.Value) error {
+		f, ok := val.(debug.Func)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Func", val, val)
 		}
@@ -1071,8 +1068,8 @@
 		return nil
 	})
 
-	checkValue("main.Z_func_nil", func(val program.Value) error {
-		f, ok := val.(program.Func)
+	checkValue("main.Z_func_nil", func(val debug.Value) error {
+		f, ok := val.(debug.Func)
 		if !ok {
 			return fmt.Errorf("got %T(%v) expected Func", val, val)
 		}
diff --git a/ogle/demo/tracee/main.go b/tests/peek/testdata/main.go
similarity index 98%
rename from ogle/demo/tracee/main.go
rename to tests/peek/testdata/main.go
index 91b942e..61a568e 100644
--- a/ogle/demo/tracee/main.go
+++ b/tests/peek/testdata/main.go
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Program for the Ogle demo to debug.
-
 package main
 
 import (