first commit

pigo/internal/cli/repl/repl_test.go

@@ -0,0 +1,656 @@
+package repl
+
+// Tests for the line-based REPL (#106): slash-command dispatch (action prints
+// message and does NOT run; prompt runs; unknown command errors and does NOT
+// run; /exit and EOF exit cleanly), multi-turn history accumulation, and
+// streaming assistant text. The REPL is driven with a fake provider so no
+// network is involved — the whole read → run → stream-print loop runs over an
+// in-memory input reader and output buffer.
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/smallnest/pigo/internal/agentcore"
+	"github.com/smallnest/pigo/internal/agenttool"
+	"github.com/smallnest/pigo/internal/cli"
+	"github.com/smallnest/pigo/internal/cli/prompts"
+	"github.com/smallnest/pigo/internal/cli/ui"
+	"github.com/smallnest/pigo/internal/provider"
+	"github.com/smallnest/pigo/internal/runtime"
+	"github.com/smallnest/pigo/internal/session"
+)
+
+// replProvider is a minimal Provider that streams one scripted text turn per
+// StreamCompletion call and records how many times it was called, so a test can
+// assert whether a run was launched.
+type replProvider struct {
+	reply string
+	calls int
+}
+
+func (p *replProvider) Name() string { return "faux" }
+func (p *replProvider) Models() []provider.Model {
+	return []provider.Model{{Provider: "faux", ID: "faux"}}
+}
+
+func (p *replProvider) StreamCompletion(ctx context.Context, req provider.CompletionRequest) (*provider.AssistantMessageEventStream, error) {
+	p.calls++
+	partial := agentcore.AssistantMessage{RoleField: agentcore.RoleAssistant}
+	withText := partial
+	withText.Content = agentcore.ContentList{agentcore.NewTextContent(p.reply)}
+	final := withText
+	final.StopReason = agentcore.StopReasonEndTurn
+	s := provider.NewAssistantMessageEventStream(0)
+	go func() {
+		_ = s.Emit(ctx, provider.StreamStartEvent{Partial: partial})
+		_ = s.Emit(ctx, provider.StreamTextEvent{Partial: withText})
+		_ = s.Emit(ctx, provider.StreamDoneEvent{Message: final})
+		s.Close()
+	}()
+	return s, nil
+}
+
+// newTestDeps builds replDeps wired to the fake provider and a temp session
+// store, with a registry carrying one action command and one prompt command so
+// slash dispatch can be exercised. actionRuns/promptResolved report whether each
+// command fired.
+func newTestDeps(t *testing.T, p provider.Provider) (replDeps, *session.Store) {
+	t.Helper()
+	store, err := session.NewStore(t.TempDir())
+	if err != nil {
+		t.Fatalf("new store: %v", err)
+	}
+	live := &cli.LiveConfig{Model: "faux", ProviderName: "faux", Provider: p}
+	reg := runtime.NewSlashRegistry()
+	reg.AddBuiltin(runtime.SlashCommand{
+		Name:   "ping",
+		Action: func(string) string { return "pong" },
+	})
+	reg.AddUser(runtime.SlashCommand{
+		Name:   "echo",
+		Expand: func(args string) string { return "expanded: " + args },
+	})
+	deps := replDeps{
+		store:    store,
+		header:   session.SessionHeader{ID: session.NewID(time.Now().UTC()), Model: "faux", Provider: "faux"},
+		agentCtx: &agentcore.AgentContext{},
+		live:     live,
+		reg:      agenttool.NewToolRegistry(),
+		slash:    reg,
+		creds:    provider.NewCredentialStore(nil),
+	}
+	return deps, store
+}
+
+// TestREPLExitCommand verifies /exit ends the loop cleanly with no error and no
+// agent run.
+func TestREPLExitCommand(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL returned error: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("/exit must not launch a run, got %d calls", p.calls)
+	}
+}
+
+// TestREPLQuitCommand verifies /quit is an alias for /exit.
+func TestREPLQuitCommand(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/quit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL returned error: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("/quit must not launch a run, got %d calls", p.calls)
+	}
+}
+
+// TestREPLEOFExits verifies EOF (no /exit) ends the loop cleanly.
+func TestREPLEOFExits(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	// Empty input → immediate EOF.
+	if err := runREPL(strings.NewReader(""), &out, deps); err != nil {
+		t.Fatalf("EOF should exit cleanly, got: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("EOF with no input must not run, got %d calls", p.calls)
+	}
+}
+
+// TestREPLFinalLineNoNewline verifies the ReadString-based loop handles a final
+// input line without a trailing newline: the line is still run as a prompt and
+// the loop then exits cleanly on EOF. (The previous bufio.Scanner had the same
+// behavior; this pins it for the reader-based loop.)
+func TestREPLFinalLineNoNewline(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("hello"), &out, deps); err != nil {
+		t.Fatalf("runREPL on no-trailing-newline input: %v", err)
+	}
+	if p.calls != 1 {
+		t.Errorf("runs fired = %d, want 1 (the final line should run once)", p.calls)
+	}
+}
+
+// TestREPLEmptyLineIgnored verifies blank lines are skipped without running.
+func TestREPLEmptyLineIgnored(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("\n   \n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("blank lines must not run, got %d calls", p.calls)
+	}
+}
+
+// TestREPLActionCommandNoRun verifies an action slash command prints its message
+// and does NOT launch an agent run.
+func TestREPLActionCommandNoRun(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/ping\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("action command must not run, got %d calls", p.calls)
+	}
+	if !strings.Contains(out.String(), "pong") {
+		t.Errorf("action command message not printed, out=%q", out.String())
+	}
+}
+
+// TestREPLPromptCommandRuns verifies a prompt slash command expands and launches
+// a run.
+func TestREPLPromptCommandRuns(t *testing.T) {
+	p := &replProvider{reply: "ack"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/echo hello\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 1 {
+		t.Fatalf("prompt command should launch exactly 1 run, got %d", p.calls)
+	}
+	// The expanded prompt must have been appended as the user message.
+	if len(deps.agentCtx.Messages) == 0 {
+		t.Fatal("expected messages in context after run")
+	}
+	first, ok := deps.agentCtx.Messages[0].(agentcore.UserMessage)
+	if !ok || agentcore.ContentToText(first.Content) != "expanded: hello" {
+		t.Errorf("first message = %T %q, want expanded prompt", deps.agentCtx.Messages[0], agentcore.ContentToText(first.Content))
+	}
+}
+
+// TestREPLUnknownCommandNoRun verifies an unknown slash command prints an error
+// and does NOT run or crash.
+func TestREPLUnknownCommandNoRun(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/nope\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("unknown command must not run, got %d calls", p.calls)
+	}
+	if !strings.Contains(strings.ToLower(out.String()), "unknown") {
+		t.Errorf("expected an unknown-command error line, out=%q", out.String())
+	}
+}
+
+// TestREPLModelSwitchTakesEffect verifies the /model action command switches the
+// live model mid-session (via registerLiveCommands + resolveProvider) without
+// launching a run, and that the switch is reflected in live for the next turn.
+func TestREPLModelSwitchTakesEffect(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	// Register the real live action commands (/model, /models, /help) against the
+	// same live config the REPL runs on, so /model mutates it.
+	prompts.RegisterLiveCommands(deps.slash, deps.live)
+
+	var out bytes.Buffer
+	// /model with no arg reports the current model; /model <id> switches to an
+	// Ollama preset (no API key required); /exit ends the loop.
+	in := strings.NewReader("/model\n/model ollama/llama3.3\n/exit\n")
+	if err := runREPL(in, &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("/model actions must not launch a run, got %d calls", p.calls)
+	}
+	if deps.live.Model != "ollama/llama3.3" || deps.live.ProviderName != "ollama" {
+		t.Errorf("live not switched: model=%q provider=%q", deps.live.Model, deps.live.ProviderName)
+	}
+	s := out.String()
+	if !strings.Contains(s, "faux") {
+		t.Errorf("/model (no arg) should report the current model, out=%q", s)
+	}
+	if !strings.Contains(s, "ollama/llama3.3") {
+		t.Errorf("/model switch should confirm the new model, out=%q", s)
+	}
+}
+
+// TestREPLPersistsModelIntoHeader verifies that after a run the session header
+// records the live model/provider (US-006: a /model switch is persisted with the
+// session), by reloading the saved session and inspecting its header.
+func TestREPLPersistsModelIntoHeader(t *testing.T) {
+	p := &replProvider{reply: "ok"}
+	deps, store := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("hello\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	headers, err := store.List()
+	if err != nil {
+		t.Fatalf("store.List: %v", err)
+	}
+	if len(headers) != 1 {
+		t.Fatalf("expected 1 saved session, got %d", len(headers))
+	}
+	if headers[0].Model != "faux" || headers[0].Provider != "faux" {
+		t.Errorf("header model/provider = %q/%q, want live faux/faux", headers[0].Model, headers[0].Provider)
+	}
+}
+
+// TestRenderToolResultTodoFull verifies the todo tool's multi-line progress
+// block is rendered in full under a "← todo:" header (US-011: REPL shows
+// progress on update), while a non-todo result stays a one-line summary.
+func TestRenderToolResultTodoFull(t *testing.T) {
+	var out bytes.Buffer
+	ui.RenderToolResult(&out, agentcore.ToolResultMessage{
+		RoleField: agentcore.RoleToolResult, ToolName: "todo",
+		Content: agentcore.ContentList{agentcore.NewTextContent("Todos:\n  [x] a\n  [ ] b\n(1/2 completed)")},
+	})
+	s := out.String()
+	for _, want := range []string{"← todo:", "[x] a", "[ ] b", "(1/2 completed)"} {
+		if !strings.Contains(s, want) {
+			t.Errorf("todo render missing %q, out=%q", want, s)
+		}
+	}
+
+	out.Reset()
+	ui.RenderToolResult(&out, agentcore.ToolResultMessage{
+		RoleField: agentcore.RoleToolResult, ToolName: "bash",
+		Content: agentcore.ContentList{agentcore.NewTextContent("line1\nline2")},
+	})
+	if got := out.String(); !strings.Contains(got, "← result: line1") {
+		t.Errorf("non-todo render = %q, want a one-line summary", got)
+	}
+}
+
+// TestReplayTranscriptRendersRoles verifies a resumed session's prior messages
+// are echoed by role (user / assistant / tool result) before the first new
+// prompt (US-006 acceptance: resumed conversation is replayed).
+func TestReplayTranscriptRendersRoles(t *testing.T) {
+	msgs := []agentcore.AgentMessage{
+		agentcore.UserMessage{RoleField: agentcore.RoleUser, Content: agentcore.ContentList{agentcore.NewTextContent("what is 2+2")}},
+		agentcore.AssistantMessage{
+			RoleField: agentcore.RoleAssistant,
+			Content:   agentcore.ContentList{agentcore.NewTextContent("Let me compute."), agentcore.NewToolCallContent("c1", "calc", []byte(`{"expr":"2+2"}`))},
+		},
+		agentcore.ToolResultMessage{RoleField: agentcore.RoleToolResult, ToolCallID: "c1", ToolName: "calc", Content: agentcore.ContentList{agentcore.NewTextContent("4")}},
+	}
+	var out bytes.Buffer
+	replayTranscript(&out, msgs)
+	s := out.String()
+	for _, want := range []string{"> what is 2+2", "Let me compute.", `→ tool: calc {"expr":"2+2"}`, "← result: 4"} {
+		if !strings.Contains(s, want) {
+			t.Errorf("replay missing %q, out=%q", want, s)
+		}
+	}
+}
+
+// TestREPLTreePrintsAndSwitchesBranch drives the /tree command end to end over
+// the REPL: after two turns, "/tree" prints a numbered tree with the current-leaf
+// marker; "/tree 1" switches the active leaf to the first node, so the next
+// prompt branches from there — leaving the original branch intact on disk (US-007,
+// #123).
+func TestREPLTreePrintsAndSwitchesBranch(t *testing.T) {
+	p := &replProvider{reply: "reply"}
+	deps, store := newTestDeps(t, p)
+	var out bytes.Buffer
+	// Two turns build a linear history (4 messages), then /tree lists it, /tree 1
+	// switches to the first node, a new prompt branches, then /exit.
+	in := strings.NewReader("first\nsecond\n/tree\n/tree 1\nbranched\n/exit\n")
+	if err := runREPL(in, &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	s := out.String()
+	if !strings.Contains(s, "← current") {
+		t.Errorf("/tree should mark the current leaf, out=%q", s)
+	}
+	if !strings.Contains(s, "1. user:") {
+		t.Errorf("/tree should number entries starting at the root user message, out=%q", s)
+	}
+	if !strings.Contains(s, "switched to branch at node 1") {
+		t.Errorf("/tree 1 should confirm the switch, out=%q", s)
+	}
+	// The on-disk tree must retain both branches: the original 4-message line plus
+	// the new branch off node 1. Reload and confirm the root has 2 children.
+	_, entries, err := store.LoadEntries(deps.header.ID)
+	if err != nil {
+		t.Fatalf("LoadEntries: %v", err)
+	}
+	rootID := ""
+	for _, e := range entries {
+		if e.ParentID == "" {
+			rootID = e.ID
+			break
+		}
+	}
+	if rootID == "" {
+		t.Fatal("no root entry found")
+	}
+	kids := 0
+	for _, e := range entries {
+		if e.ParentID == rootID {
+			kids++
+		}
+	}
+	if kids != 2 {
+		t.Errorf("root should have 2 children after branching, got %d (entries=%d)", kids, len(entries))
+	}
+}
+
+// TestREPLTreeEmptyNoop verifies /tree on a fresh session (no messages) prints a
+// friendly notice and does not crash or run.
+func TestREPLTreeEmptyNoop(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/tree\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("/tree must not launch a run, got %d calls", p.calls)
+	}
+	if !strings.Contains(out.String(), "empty") {
+		t.Errorf("/tree on empty session should say so, out=%q", out.String())
+	}
+}
+
+// is printed, and history accumulates across two turns in the shared context.
+func TestREPLStreamsAndAccumulatesHistory(t *testing.T) {
+	p := &replProvider{reply: "the answer"}
+	deps, store := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("first question\nsecond question\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 2 {
+		t.Fatalf("two prompts should launch 2 runs, got %d", p.calls)
+	}
+	// The streamed reply text must appear in the output.
+	if !strings.Contains(out.String(), "the answer") {
+		t.Errorf("assistant reply not streamed to output, out=%q", out.String())
+	}
+	// History: user(first) + assistant + user(second) + assistant = 4 messages.
+	if len(deps.agentCtx.Messages) != 4 {
+		t.Fatalf("expected 4 accumulated messages, got %d", len(deps.agentCtx.Messages))
+	}
+	u0, _ := deps.agentCtx.Messages[0].(agentcore.UserMessage)
+	u2, _ := deps.agentCtx.Messages[2].(agentcore.UserMessage)
+	if agentcore.ContentToText(u0.Content) != "first question" || agentcore.ContentToText(u2.Content) != "second question" {
+		t.Errorf("history not accumulated in order: %q, %q", agentcore.ContentToText(u0.Content), agentcore.ContentToText(u2.Content))
+	}
+	// The session must have been persisted after the runs.
+	headers, err := store.List()
+	if err != nil {
+		t.Fatalf("store.List: %v", err)
+	}
+	if len(headers) != 1 {
+		t.Errorf("expected 1 saved session, got %d", len(headers))
+	}
+}
+
+// errProvider streams a single turn that ends with stopReason error carrying an
+// ErrorMessage, mimicking how the loop surfaces a request failure (e.g. a 4xx
+// from the endpoint) as a terminal assistant message rather than a Go error.
+type errProvider struct {
+	reason string
+	calls  int
+}
+
+func (p *errProvider) Name() string { return "faux" }
+func (p *errProvider) Models() []provider.Model {
+	return []provider.Model{{Provider: "faux", ID: "faux"}}
+}
+
+func (p *errProvider) StreamCompletion(ctx context.Context, req provider.CompletionRequest) (*provider.AssistantMessageEventStream, error) {
+	p.calls++
+	partial := agentcore.AssistantMessage{RoleField: agentcore.RoleAssistant}
+	final := partial
+	final.StopReason = agentcore.StopReasonError
+	final.ErrorMessage = p.reason
+	s := provider.NewAssistantMessageEventStream(0)
+	go func() {
+		_ = s.Emit(ctx, provider.StreamStartEvent{Partial: partial})
+		_ = s.Emit(ctx, provider.StreamErrorEvent{Message: final})
+		s.Close()
+	}()
+	return s, nil
+}
+
+// TestREPLSurfacesTurnError verifies a turn that ends with stopReason error is
+// printed to the user instead of returning silently to the prompt. Without this
+// an API failure (delivered as a terminal error message, not a run error) would
+// produce no output at all.
+func TestREPLSurfacesTurnError(t *testing.T) {
+	p := &errProvider{reason: "401 unauthorized: bad api key"}
+	deps, _ := newTestDeps(t, p)
+	deps.live.Provider = p
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("hello\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 1 {
+		t.Fatalf("expected 1 run, got %d", p.calls)
+	}
+	got := out.String()
+	if !strings.Contains(got, "error:") || !strings.Contains(got, "401 unauthorized: bad api key") {
+		t.Errorf("turn error not surfaced to output, out=%q", got)
+	}
+}
+
+// emptyProvider streams a clean end_turn with no content, thinking, or tool
+// calls — the shape produced when an endpoint accepts the request with a 200 but
+// returns nothing this protocol can decode.
+type emptyProvider struct{ calls int }
+
+func (p *emptyProvider) Name() string { return "faux" }
+func (p *emptyProvider) Models() []provider.Model {
+	return []provider.Model{{Provider: "faux", ID: "faux"}}
+}
+
+func (p *emptyProvider) StreamCompletion(ctx context.Context, req provider.CompletionRequest) (*provider.AssistantMessageEventStream, error) {
+	p.calls++
+	partial := agentcore.AssistantMessage{RoleField: agentcore.RoleAssistant}
+	final := partial
+	final.StopReason = agentcore.StopReasonEndTurn
+	s := provider.NewAssistantMessageEventStream(0)
+	go func() {
+		_ = s.Emit(ctx, provider.StreamStartEvent{Partial: partial})
+		_ = s.Emit(ctx, provider.StreamDoneEvent{Message: final})
+		s.Close()
+	}()
+	return s, nil
+}
+
+// TestREPLNotesEmptyResponse verifies a clean turn that produced no output at
+// all is flagged with a note rather than returning silently to the prompt.
+func TestREPLNotesEmptyResponse(t *testing.T) {
+	p := &emptyProvider{}
+	deps, _ := newTestDeps(t, p)
+	deps.live.Provider = p
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("hello\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 1 {
+		t.Fatalf("expected 1 run, got %d", p.calls)
+	}
+	if got := out.String(); !strings.Contains(got, "empty response from the model") {
+		t.Errorf("empty response not flagged, out=%q", got)
+	}
+}
+
+// TestREPLExportImportRoundTrip drives /export and /import end to end over the
+// REPL: after a turn, "/export <path>" writes a JSONL file, then "/import
+// <path>" materializes it as a fresh session and switches to it (US-008, #124).
+func TestREPLExportImportRoundTrip(t *testing.T) {
+	p := &replProvider{reply: "the answer"}
+	deps, store := newTestDeps(t, p)
+	origID := deps.header.ID
+	out := filepath.Join(t.TempDir(), "sess.jsonl")
+
+	var buf bytes.Buffer
+	in := strings.NewReader("hello\n/export " + out + "\n/import " + out + "\n/exit\n")
+	if err := runREPL(in, &buf, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	s := buf.String()
+	if !strings.Contains(s, "exported") {
+		t.Errorf("/export should confirm, out=%q", s)
+	}
+	if !strings.Contains(s, "imported") {
+		t.Errorf("/import should confirm, out=%q", s)
+	}
+	// The export file must exist and be non-empty.
+	if info, err := os.Stat(out); err != nil || info.Size() == 0 {
+		t.Fatalf("export file missing or empty: err=%v", err)
+	}
+	// The import creates a new session distinct from the original, so the store
+	// should now hold at least 2 sessions.
+	headers, err := store.List()
+	if err != nil {
+		t.Fatalf("store.List: %v", err)
+	}
+	var foundNew bool
+	for _, h := range headers {
+		if h.ID != origID && h.ParentSession == origID {
+			foundNew = true
+		}
+	}
+	if !foundNew {
+		t.Errorf("expected an imported session with ParentSession=%q, headers=%+v", origID, headers)
+	}
+}
+
+// TestREPLExportDefaultsToJSONL verifies "/export" with no path defaults to
+// "<session-id>.jsonl" and does not launch an agent run.
+func TestREPLExportDefaultsToJSONL(t *testing.T) {
+	p := &replProvider{reply: "ok"}
+	deps, _ := newTestDeps(t, p)
+	dir := t.TempDir()
+	// Run inside a temp dir so the default relative filename lands there.
+	cwd, _ := os.Getwd()
+	if err := os.Chdir(dir); err != nil {
+		t.Fatalf("chdir: %v", err)
+	}
+	defer os.Chdir(cwd)
+
+	var buf bytes.Buffer
+	if err := runREPL(strings.NewReader("hi\n/export\n/exit\n"), &buf, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	want := deps.header.ID + ".jsonl"
+	if _, err := os.Stat(filepath.Join(dir, want)); err != nil {
+		t.Errorf("default export file %q not created: %v", want, err)
+	}
+}
+
+// TestREPLImportTokenBoundary verifies that a command sharing a prefix with
+// /import (e.g. "/important") is NOT treated as /import — it falls through to
+// slash resolution and reports an unknown command rather than importing.
+func TestREPLImportTokenBoundary(t *testing.T) {
+	p := &replProvider{reply: "ok"}
+	deps, _ := newTestDeps(t, p)
+	var buf bytes.Buffer
+	if err := runREPL(strings.NewReader("/important\n/exit\n"), &buf, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if strings.Contains(buf.String(), "imported") {
+		t.Errorf("/important must not trigger /import, out=%q", buf.String())
+	}
+	if p.calls != 0 {
+		t.Errorf("/important should not launch a run, got %d calls", p.calls)
+	}
+}
+
+// TestREPLSessionStats drives the /session command: after a turn it prints the
+// session id, message count, token estimate, model, and compaction count without
+// launching another run (US-009, #125).
+func TestREPLSessionStats(t *testing.T) {
+	p := &replProvider{reply: "the answer"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("hello\n/session\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 1 {
+		t.Errorf("/session must not launch a run (only the prompt), got %d calls", p.calls)
+	}
+	s := out.String()
+	for _, want := range []string{"session:", "messages:", "tokens (est):", "model:", "compactions:"} {
+		if !strings.Contains(s, want) {
+			t.Errorf("/session output missing %q, out=%q", want, s)
+		}
+	}
+	// After one turn the context holds user + assistant = 2 messages.
+	if !strings.Contains(s, "messages:     2") {
+		t.Errorf("/session should report 2 messages, out=%q", s)
+	}
+}
+
+// TestREPLCopyEmpty verifies /copy on a session with no assistant reply prints a
+// friendly notice rather than copying or crashing.
+func TestREPLCopyEmpty(t *testing.T) {
+	p := &replProvider{reply: "hi"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("/copy\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	if p.calls != 0 {
+		t.Errorf("/copy must not launch a run, got %d calls", p.calls)
+	}
+	if !strings.Contains(out.String(), "nothing to copy") {
+		t.Errorf("/copy on empty session should say so, out=%q", out.String())
+	}
+}
+
+// TestREPLCopyDegradesToPrint verifies /copy degrades to printing the last reply
+// when no clipboard utility is available (PATH pointed at an empty dir), so the
+// content is never lost.
+func TestREPLCopyDegradesToPrint(t *testing.T) {
+	t.Setenv("PATH", t.TempDir())
+	p := &replProvider{reply: "the important answer"}
+	deps, _ := newTestDeps(t, p)
+	var out bytes.Buffer
+	if err := runREPL(strings.NewReader("ask\n/copy\n/exit\n"), &out, deps); err != nil {
+		t.Fatalf("runREPL: %v", err)
+	}
+	s := out.String()
+	if !strings.Contains(s, "no clipboard utility") {
+		t.Errorf("/copy should report missing clipboard utility, out=%q", s)
+	}
+	if !strings.Contains(s, "the important answer") {
+		t.Errorf("/copy should print the reply when degrading, out=%q", s)
+	}
+}