@pi-in-go/pigpen-session-ingest 0.1.0

package/extensions/session-ingest/modes_test.go

@@ -0,0 +1,254 @@
+package sessioningest
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+// Cases for the modes the retrieval hints point at: turn, tools and stats.
+
+func writeRichFixture(t *testing.T) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "rich.jsonl")
+	content := strings.Join([]string{
+		`{"type":"session","id":"session-rich-000000","version":"3","cwd":"/repo","timestamp":"2026-05-24T10:00:00.000Z"}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:01.000Z","message":{"role":"user","content":[{"type":"text","text":"Fix the parser"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:02.000Z","message":{"role":"assistant","provider":"acme","model":"m-1","content":[{"type":"thinking","thinking":"secret reasoning"},{"type":"text","text":"Reading first."},{"type":"toolCall","id":"c1","name":"read","arguments":{"path":"parser.go"}},{"type":"toolCall","id":"c2","name":"bash","arguments":{"command":"go test ./..."}}],"usage":{"input":100,"output":50,"cacheRead":10,"cacheWrite":5,"totalTokens":165,"cost":{"total":0.5}}}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:03.000Z","message":{"role":"toolResult","toolName":"read","toolCallId":"c1","content":[{"type":"text","text":"package parser"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:04.000Z","message":{"role":"toolResult","toolName":"bash","toolCallId":"c2","isError":true,"content":[{"type":"text","text":"FAIL parser"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:05.000Z","message":{"role":"assistant","provider":"acme","model":"m-1","content":[{"type":"toolCall","id":"c3","name":"edit","arguments":{"path":"parser.go","edits":[]}}],"usage":{"input":200,"output":20,"totalTokens":220,"cost":{"total":0.25}}}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:06.000Z","message":{"role":"toolResult","toolName":"edit","toolCallId":"c3","content":[{"type":"text","text":"edited"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:07.000Z","message":{"role":"user","content":"Thanks"}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:10.000Z","message":{"role":"assistant","provider":"acme","model":"m-2","stopReason":"error","errorMessage":"rate limited","content":[]}}`,
+		`{"type":"model_change","provider":"acme","modelId":"m-2","timestamp":"2026-05-24T10:00:08.000Z"}`,
+	}, "\n") + "\n"
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func run(t *testing.T, params map[string]any) any {
+	t.Helper()
+	got, err := handleReadSession(sdk.Context{}, params)
+	if err != nil {
+		t.Fatalf("handleReadSession(%v) error = %v", params, err)
+	}
+	return got
+}
+
+func TestTurnModeJSONReturnsTheWholeTurn(t *testing.T) {
+	report, ok := run(t, map[string]any{"path": writeRichFixture(t), "mode": "turn", "turn": 1, "format": "json"}).(turnReport)
+	if !ok {
+		t.Fatal("result is not a turnReport")
+	}
+	if report.Turn != 1 || report.TotalTurns != 2 {
+		t.Fatalf("turn/total = %d/%d, want 1/2", report.Turn, report.TotalTurns)
+	}
+	roles := []string{}
+	for _, m := range report.Messages {
+		roles = append(roles, m.Role)
+	}
+	if strings.Join(roles, ",") != "user,assistant,toolResult,toolResult,assistant,toolResult" {
+		t.Fatalf("roles = %v", roles)
+	}
+}
+
+func TestTurnModeDefaultsAreTokenSafe(t *testing.T) {
+	res := run(t, map[string]any{"path": writeRichFixture(t), "mode": "turn", "turn": 1}).(sdk.ToolResult)
+	text := res.Content
+	for _, want := range []string{"# Session turn 1 of 2", "Fix the parser", "Reading first.", "read", "bash", "errors"} {
+		if !strings.Contains(text, want) {
+			t.Errorf("missing %q:\n%s", want, text)
+		}
+	}
+	// Raw thinking and tool results are hidden unless asked for.
+	for _, hidden := range []string{"secret reasoning", "package parser", "FAIL parser"} {
+		if strings.Contains(text, hidden) {
+			t.Errorf("default output leaks %q:\n%s", hidden, text)
+		}
+	}
+	if res.Preview == "" {
+		t.Error("expected a Preview")
+	}
+}
+
+func TestTurnModeIncludeOptIns(t *testing.T) {
+	res := run(t, map[string]any{
+		"path": writeRichFixture(t), "mode": "turn", "turn": 1,
+		"include": []any{"text", "thinking", "tool_results", "usage"},
+	}).(sdk.ToolResult)
+	for _, want := range []string{"secret reasoning", "package parser", "FAIL parser", "$0.5000"} {
+		if !strings.Contains(res.Content, want) {
+			t.Errorf("missing %q:\n%s", want, res.Content)
+		}
+	}
+}
+
+func TestTurnModeHonorsMaxCharsPerItem(t *testing.T) {
+	res := run(t, map[string]any{
+		"path": writeRichFixture(t), "mode": "turn", "turn": 1, "include": []any{"text", "tool_results"}, "maxCharsPerItem": 4,
+	}).(sdk.ToolResult)
+	if strings.Contains(res.Content, "package parser") || !strings.Contains(res.Content, "truncated") {
+		t.Fatalf("expected truncated tool result:\n%s", res.Content)
+	}
+}
+
+func TestTurnModeValidatesTurn(t *testing.T) {
+	path := writeRichFixture(t)
+	for name, params := range map[string]map[string]any{
+		"missing": {"path": path, "mode": "turn"},
+		"zero":    {"path": path, "mode": "turn", "turn": 0},
+		"past":    {"path": path, "mode": "turn", "turn": 3},
+	} {
+		if _, err := handleReadSession(sdk.Context{}, params); err == nil || !strings.Contains(err.Error(), "turn") {
+			t.Errorf("%s: err = %v, want a turn error", name, err)
+		}
+	}
+}
+
+func TestToolsModeCountsCallsResultsErrorsAndFiles(t *testing.T) {
+	report, ok := run(t, map[string]any{"path": writeRichFixture(t), "mode": "tools", "format": "json"}).(toolsReport)
+	if !ok {
+		t.Fatal("result is not a toolsReport")
+	}
+	byName := map[string]toolUsage{}
+	for _, u := range report.Tools {
+		byName[u.Name] = u
+	}
+	if u := byName["bash"]; u.Calls != 1 || u.Results != 1 || u.Errors != 1 {
+		t.Errorf("bash = %+v", u)
+	}
+	if u := byName["read"]; u.Calls != 1 || u.Results != 1 || u.Errors != 0 || u.FirstTurn != 1 {
+		t.Errorf("read = %+v", u)
+	}
+	if report.TotalCalls != 3 {
+		t.Errorf("TotalCalls = %d, want 3", report.TotalCalls)
+	}
+	files := map[string]string{}
+	for _, f := range report.Files {
+		files[f.Path] = strings.Join(f.Tools, "+")
+	}
+	if files["parser.go"] != "edit+read" {
+		t.Errorf("files = %v, want parser.go touched by edit+read", files)
+	}
+}
+
+func TestToolsModeMarkdownAndTurnFilter(t *testing.T) {
+	res := run(t, map[string]any{"path": writeRichFixture(t), "mode": "tools", "turn": 2}).(sdk.ToolResult)
+	if !strings.Contains(res.Content, "# Session tools") || !strings.Contains(res.Content, "No tool calls") {
+		t.Fatalf("turn 2 has no tools:\n%s", res.Content)
+	}
+	res = run(t, map[string]any{"path": writeRichFixture(t), "mode": "tools"}).(sdk.ToolResult)
+	for _, want := range []string{"| bash |", "| read |", "parser.go"} {
+		if !strings.Contains(res.Content, want) {
+			t.Errorf("missing %q:\n%s", want, res.Content)
+		}
+	}
+}
+
+func TestStatsModeTotals(t *testing.T) {
+	report, ok := run(t, map[string]any{"path": writeRichFixture(t), "mode": "stats", "format": "json"}).(statsReport)
+	if !ok {
+		t.Fatal("result is not a statsReport")
+	}
+	if report.Turns != 2 || report.Messages != 8 {
+		t.Errorf("turns/messages = %d/%d, want 2/8", report.Turns, report.Messages)
+	}
+	want := map[string]int{"user": 2, "assistant": 3, "toolResult": 3}
+	for role, n := range want {
+		if report.Roles[role] != n {
+			t.Errorf("roles[%s] = %d, want %d", role, report.Roles[role], n)
+		}
+	}
+	if report.Usage.Input != 300 || report.Usage.Output != 70 || report.Usage.Total != 385 || report.Usage.Cost != 0.75 {
+		t.Errorf("usage = %+v", report.Usage)
+	}
+	if report.ToolCalls != 3 || report.Errors != 2 {
+		t.Errorf("toolCalls/errors = %d/%d, want 3/2 (one tool error, one provider error)", report.ToolCalls, report.Errors)
+	}
+	models := map[string]int{}
+	for _, m := range report.Models {
+		models[m.Model] = m.Messages
+	}
+	if models["m-1"] != 2 || models["m-2"] != 1 {
+		t.Errorf("models = %v", models)
+	}
+	if report.DurationSeconds != 9 {
+		t.Errorf("duration = %d, want 9 (first to last message)", report.DurationSeconds)
+	}
+}
+
+func TestStatsModeMarkdown(t *testing.T) {
+	res := run(t, map[string]any{"path": writeRichFixture(t), "mode": "stats"}).(sdk.ToolResult)
+	for _, want := range []string{"# Session stats", "turns: 2", "tokens", "$0.7500", "m-1", "m-2"} {
+		if !strings.Contains(res.Content, want) {
+			t.Errorf("missing %q:\n%s", want, res.Content)
+		}
+	}
+}
+
+func TestSchemaHasNoUnusedFields(t *testing.T) {
+	props := readSessionSchema()["properties"].(map[string]any)
+	if _, ok := props["contextRadius"]; ok {
+		t.Error("contextRadius is not used by any mode and must not be in the schema")
+	}
+}
+
+func TestContinuationHintOnlyWhenThereIsMore(t *testing.T) {
+	path := writeRichFixture(t)
+	all := run(t, map[string]any{"path": path, "mode": "toc", "limit": 10}).(sdk.ToolResult).Content
+	if strings.Contains(all, "[Next:") {
+		t.Errorf("all turns fit but a Next hint was added:\n%s", all)
+	}
+	exact := run(t, map[string]any{"path": path, "mode": "toc", "limit": 2}).(sdk.ToolResult).Content
+	if strings.Contains(exact, "[Next:") {
+		t.Errorf("the page ends exactly at the last turn but a Next hint was added:\n%s", exact)
+	}
+	partial := run(t, map[string]any{"path": path, "mode": "toc", "limit": 1}).(sdk.ToolResult).Content
+	if !strings.Contains(partial, `"start":1`) {
+		t.Errorf("partial page needs a hint for start=1:\n%s", partial)
+	}
+	for _, mode := range []string{"stats"} {
+		out := run(t, map[string]any{"path": path, "mode": mode}).(sdk.ToolResult).Content
+		if strings.Contains(out, "[Next:") {
+			t.Errorf("mode %s has no pages but got a Next hint:\n%s", mode, out)
+		}
+	}
+}
+
+func TestTruncationNeverSplitsARune(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "u.jsonl")
+	line := `{"type":"message","message":{"role":"user","content":"` + strings.Repeat("é", 50) + `"}}`
+	if err := os.WriteFile(path, []byte(line+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	res := run(t, map[string]any{"path": path, "mode": "turn", "turn": 1, "maxCharsPerItem": 11}).(sdk.ToolResult)
+	if !utf8.ValidString(res.Content) {
+		t.Fatalf("output is not valid UTF-8: %q", res.Content)
+	}
+	q := run(t, map[string]any{"path": path, "mode": "query", "query": "é", "maxCharsPerItem": 11, "format": "json"}).(queryReport)
+	if !utf8.ValidString(q.Hits[0].Excerpt) {
+		t.Fatalf("excerpt is not valid UTF-8: %q", q.Hits[0].Excerpt)
+	}
+}
+
+func TestOversizedTurnExplainsHowToNarrow(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "big.jsonl")
+	line := `{"type":"message","message":{"role":"user","content":"` + strings.Repeat("x", 60*1024) + `"}}`
+	if err := os.WriteFile(path, []byte(line+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	out := run(t, map[string]any{"path": path, "mode": "turn", "turn": 1}).(sdk.ToolResult).Content
+	if !strings.Contains(out, "maxCharsPerItem") {
+		t.Errorf("truncated turn should say how to narrow it:\n%s", out[len(out)-300:])
+	}
+	if len(out) > 51*1024 {
+		t.Errorf("output is %d bytes, over the 50 KB cap", len(out))
+	}
+}

package/extensions/session-ingest/parse_allocs_test.go

@@ -0,0 +1,36 @@
+package sessioningest
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Each line of the file used to be copied twice before it was decoded (Scanner.Text, then []byte of that string).
+func TestParseSessionFileDoesNotCopyEachLineTwice(t *testing.T) {
+	var lines []string
+	lines = append(lines, `{"type":"session","id":"s1","version":3,"cwd":"/w","timestamp":"2026-01-01T00:00:00Z"}`)
+	pad := strings.Repeat("x", 4000)
+	for i := 0; i < 50; i++ {
+		lines = append(lines, `{"type":"message","id":"m","message":{"role":"toolResult","toolName":"bash","content":[{"type":"text","text":"`+pad+`"}]}}`)
+	}
+	path := filepath.Join(t.TempDir(), "s.jsonl")
+	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")+"\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	var bytes float64
+	allocBytes := testing.Benchmark(func(b *testing.B) {
+		b.ReportAllocs()
+		for i := 0; i < b.N; i++ {
+			if s, err := parseSessionFile(path, 100000); err != nil || len(s.Messages) != 50 {
+				b.Fatal(err, len(s.Messages))
+			}
+		}
+	})
+	bytes = float64(allocBytes.AllocedBytesPerOp())
+	// 50 lines of ~4.1 KB: the decoded text is kept (about 205 KB); a second copy of every line is not.
+	if bytes > 205_000*2.6 {
+		t.Fatalf("parsing allocated %.0f bytes for a 205 KB file; each line is being copied more than once", bytes)
+	}
+}

package/extensions/session-ingest/review_test.go

@@ -0,0 +1,53 @@
+package sessioningest
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"unicode/utf8"
+)
+
+// Cases added by the adversarial review of the move.
+
+func writeOneUserMessage(t *testing.T, text string) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "one.jsonl")
+	line := `{"type":"message","message":{"role":"user","content":"` + text + `"}}`
+	if err := os.WriteFile(path, []byte(line+"\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+// maxCharsPerItem shortens what is shown. It must not shrink what is searched: a
+// match past the first maxCharsPerItem characters is still a hit.
+func TestQueryFindsMatchesPastMaxCharsPerItem(t *testing.T) {
+	path := writeOneUserMessage(t, strings.Repeat("a", 500)+" needle "+strings.Repeat("b", 500))
+	for _, caseSensitive := range []bool{false, true} {
+		q := run(t, map[string]any{"path": path, "mode": "query", "query": "needle", "caseSensitive": caseSensitive, "maxCharsPerItem": 100, "format": "json"}).(queryReport)
+		if q.TotalHits != 1 {
+			t.Fatalf("caseSensitive=%v: hits = %d, want 1 (the match is at character 501)", caseSensitive, q.TotalHits)
+		}
+		if !strings.Contains(q.Hits[0].Excerpt, "needle") {
+			t.Errorf("caseSensitive=%v: the excerpt must be centered on the match: %q", caseSensitive, q.Hits[0].Excerpt)
+		}
+		if n := utf8.RuneCountInString(q.Hits[0].Excerpt); n > 100+len(" ... [truncated, 9999 chars total]") {
+			t.Errorf("caseSensitive=%v: excerpt is %d characters, want it bounded by maxCharsPerItem", caseSensitive, n)
+		}
+	}
+}
+
+// Case folding can change byte lengths (U+0130 is 2 bytes, its lower case 3), so
+// a match offset taken from strings.ToLower(text) is wrong in text itself.
+func TestCaseInsensitiveExcerptUsesOffsetsOfTheOriginalText(t *testing.T) {
+	path := writeOneUserMessage(t, strings.Repeat("İ", 300)+" needle "+strings.Repeat("z", 300))
+	q := run(t, map[string]any{"path": path, "mode": "query", "query": "NEEDLE", "format": "json"}).(queryReport)
+	if q.TotalHits != 1 {
+		t.Fatalf("hits = %d, want 1", q.TotalHits)
+	}
+	excerpt := q.Hits[0].Excerpt
+	if !strings.Contains(excerpt, "needle") || !utf8.ValidString(excerpt) {
+		t.Fatalf("excerpt does not show the match, or splits a character: %q", excerpt)
+	}
+}

package/extensions/session-ingest/session_test.go

@@ -0,0 +1,267 @@
+package sessioningest
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+func TestReadSessionTOCJSON(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":   path,
+		"mode":   "toc",
+		"format": "json",
+		"limit":  10,
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	report, ok := got.(tocReport)
+	if !ok {
+		t.Fatalf("result type = %T, want tocReport", got)
+	}
+	if report.TotalTurns != 2 {
+		t.Fatalf("TotalTurns = %d, want 2", report.TotalTurns)
+	}
+	if report.Session.ID != "session-1234567890" {
+		t.Fatalf("session ID = %q", report.Session.ID)
+	}
+	if len(report.Items) != 2 {
+		t.Fatalf("items = %d, want 2", len(report.Items))
+	}
+	first := report.Items[0]
+	if first.TurnIndex != 1 || first.EntryIndex != 2 || first.MessageIndex != 1 {
+		t.Fatalf("first indices = %+v", first)
+	}
+	if first.User != "Please inspect the repo" {
+		t.Fatalf("first user = %q", first.User)
+	}
+	if strings.Join(first.Tools, ",") != "bash,read" {
+		t.Fatalf("first tools = %v, want bash/read", first.Tools)
+	}
+	if first.AssistantMessages != 1 || first.ToolResults != 1 || first.Errors != 1 {
+		t.Fatalf("first counts = %+v", first)
+	}
+	if first.Usage.Total != 30 || first.Usage.Cost != 0.12 {
+		t.Fatalf("first usage = %+v", first.Usage)
+	}
+}
+
+func TestReadSessionTOCMarkdown(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":   path,
+		"mode":   "toc",
+		"format": "compact_markdown",
+		"limit":  1,
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	result, ok := got.(sdk.ToolResult)
+	if !ok {
+		t.Fatalf("result type = %T, want sdk.ToolResult", got)
+	}
+	text := result.Content
+	for _, want := range []string{"# Session TOC", "session-123", "| 1 |", "Please inspect the repo", "bash, read", "errors:1"} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("markdown missing %q:\n%s", want, text)
+		}
+	}
+	if strings.Contains(text, "| 2 |") {
+		t.Fatalf("markdown included turn 2 despite limit=1:\n%s", text)
+	}
+	if result.Preview == "" {
+		t.Fatal("expected non-empty Preview")
+	}
+	if !strings.Contains(result.Preview, "2 turns") {
+		t.Errorf("preview should mention total turns: %q", result.Preview)
+	}
+}
+
+func TestReadSessionQueryJSON(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":   path,
+		"mode":   "query",
+		"query":  "inspect",
+		"format": "json",
+		"limit":  10,
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	report, ok := got.(queryReport)
+	if !ok {
+		t.Fatalf("result type = %T, want queryReport", got)
+	}
+	if report.TotalHits != 2 {
+		t.Fatalf("TotalHits = %d, want 2", report.TotalHits)
+	}
+	if len(report.Hits) != 2 {
+		t.Fatalf("hits = %d, want 2", len(report.Hits))
+	}
+	if report.Hits[0].Role != "user" || report.Hits[0].TurnIndex != 1 || !strings.Contains(report.Hits[0].Excerpt, "inspect") {
+		t.Fatalf("first hit = %+v, want user turn 1 inspect", report.Hits[0])
+	}
+	if report.Hits[1].Role != "assistant" || report.Hits[1].TurnIndex != 1 {
+		t.Fatalf("second hit = %+v, want assistant turn 1", report.Hits[1])
+	}
+}
+
+func TestReadSessionQueryFindsToolResultsAndHonorsCaseSensitivity(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":          path,
+		"mode":          "query",
+		"query":         "BOOM",
+		"caseSensitive": false,
+		"format":        "json",
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	report := got.(queryReport)
+	if report.TotalHits != 1 || report.Hits[0].Role != "toolResult" || report.Hits[0].ToolName != "bash" {
+		t.Fatalf("report = %+v, want bash toolResult hit", report)
+	}
+
+	got, err = handleReadSession(sdk.Context{}, map[string]any{
+		"path":          path,
+		"mode":          "query",
+		"query":         "BOOM",
+		"caseSensitive": true,
+		"format":        "json",
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	report = got.(queryReport)
+	if report.TotalHits != 0 {
+		t.Fatalf("case-sensitive TotalHits = %d, want 0", report.TotalHits)
+	}
+}
+
+func TestReadSessionQueryMarkdown(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":   path,
+		"mode":   "query",
+		"query":  "Done",
+		"format": "compact_markdown",
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	result, ok := got.(sdk.ToolResult)
+	if !ok {
+		t.Fatalf("result type = %T, want sdk.ToolResult", got)
+	}
+	text := result.Content
+	for _, want := range []string{"# Session query", "Done", "| 1 | 2 | assistant", "mode=turn turn=2"} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("markdown missing %q:\n%s", want, text)
+		}
+	}
+	if result.Preview == "" {
+		t.Fatal("expected non-empty Preview")
+	}
+}
+
+func TestReadSessionSliceJSONWithRoleFilter(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":   path,
+		"mode":   "slice",
+		"format": "json",
+		"start":  0,
+		"limit":  2,
+		"roles":  []any{"assistant"},
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	report, ok := got.(sliceReport)
+	if !ok {
+		t.Fatalf("result type = %T, want sliceReport", got)
+	}
+	if report.FilteredTotal != 2 || len(report.Messages) != 2 {
+		t.Fatalf("filtered/messages = %d/%d, want 2/2", report.FilteredTotal, len(report.Messages))
+	}
+	if report.Messages[0].Role != "assistant" || report.Messages[0].TurnIndex != 1 || len(report.Messages[0].ToolCalls) != 2 {
+		t.Fatalf("first slice message = %+v", report.Messages[0])
+	}
+	if report.Messages[1].TurnIndex != 2 || report.Messages[1].Text[0] != "Done." {
+		t.Fatalf("second slice message = %+v", report.Messages[1])
+	}
+}
+
+func TestReadSessionSliceMarkdown(t *testing.T) {
+	path := writeSessionFixture(t)
+	got, err := handleReadSession(sdk.Context{}, map[string]any{
+		"path":   path,
+		"mode":   "slice",
+		"format": "compact_markdown",
+		"start":  1,
+		"limit":  2,
+	})
+	if err != nil {
+		t.Fatalf("handleReadSession() error = %v", err)
+	}
+	result, ok := got.(sdk.ToolResult)
+	if !ok {
+		t.Fatalf("result type = %T, want sdk.ToolResult", got)
+	}
+	text := result.Content
+	for _, want := range []string{"# Session slice", "message 2 turn 1 assistant", "tool_calls: bash, read", "message 3 turn 1 toolResult"} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("markdown missing %q:\n%s", want, text)
+		}
+	}
+	if result.Preview == "" {
+		t.Fatal("expected non-empty Preview")
+	}
+}
+
+func TestReadSessionQueryRequiresQuery(t *testing.T) {
+	path := writeSessionFixture(t)
+	_, err := handleReadSession(sdk.Context{}, map[string]any{"path": path, "mode": "query"})
+	if err == nil || !strings.Contains(err.Error(), "query is required") {
+		t.Fatalf("err = %v, want query required", err)
+	}
+}
+
+func TestReadSessionRejectsUnknownMode(t *testing.T) {
+	_, err := handleReadSession(sdk.Context{}, map[string]any{"path": "x", "mode": "missing"})
+	if err == nil || !strings.Contains(err.Error(), "unknown mode") {
+		t.Fatalf("err = %v, want unknown mode", err)
+	}
+}
+
+func TestReadSessionReportsMissingPath(t *testing.T) {
+	_, err := handleReadSession(sdk.Context{}, map[string]any{"mode": "toc"})
+	if err == nil || !strings.Contains(err.Error(), "path is required") {
+		t.Fatalf("err = %v, want path required", err)
+	}
+}
+
+func writeSessionFixture(t *testing.T) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "session.jsonl")
+	content := strings.Join([]string{
+		`{"type":"session","id":"session-1234567890","version":"0.75.4","cwd":"/repo","timestamp":"2026-05-24T10:00:00.000Z"}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:01.000Z","message":{"role":"user","content":[{"type":"text","text":"Please inspect the repo"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:02.000Z","message":{"role":"assistant","content":[{"type":"text","text":"I will inspect it."},{"type":"toolCall","id":"call-1","name":"bash","arguments":{"command":"ls"}},{"type":"toolCall","id":"call-2","name":"read","arguments":{"path":"README.md"}}],"usage":{"input":10,"output":20,"totalTokens":30,"cost":{"total":0.12}}}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:03.000Z","message":{"role":"toolResult","toolName":"bash","isError":true,"content":[{"type":"text","text":"boom"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:04.000Z","message":{"role":"user","content":[{"type":"text","text":"Continue"}]}}`,
+		`{"type":"message","timestamp":"2026-05-24T10:00:05.000Z","message":{"role":"assistant","content":[{"type":"text","text":"Done."}],"usage":{"input":1,"output":2,"totalTokens":3}}}`,
+	}, "\n") + "\n"
+	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@pi-in-go/pigpen-session-ingest",
+  "version": "0.1.0",
+  "description": "read_session: a token-safe tool that lets the model query Pi and PiG JSONL session transcripts (contents, search, single turns, tool usage, stats)",
+  "keywords": [
+    "pig-package",
+    "sessions",
+    "history",
+    "extension",
+    "pigpen"
+  ],
+  "license": "MIT",
+  "author": "Michael Kinsy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MichaelKinsy/pigpen.git",
+    "directory": "components/session-ingest"
+  },
+  "homepage": "https://github.com/MichaelKinsy/pigpen/tree/main/components/session-ingest#readme",
+  "bugs": {
+    "url": "https://github.com/MichaelKinsy/pigpen/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "extensions",
+    "README.md",
+    "LICENSE",
+    "CREDITS.md",
+    "provenance.json"
+  ],
+  "pi": {
+    "extensions": [
+      "extensions/session-ingest"
+    ]
+  }
+}

package/provenance.json

@@ -0,0 +1,7 @@
+{
+  "origin": "original",
+  "authors": ["Michael Kinsy"],
+  "license": "MIT",
+  "licenseFile": "LICENSE",
+  "upstreams": []
+}