diff --git a/internal/stage/pi_session_export.go b/internal/stage/pi_session_export.go
new file mode 100644
index 00000000..0b911914
--- /dev/null
+++ b/internal/stage/pi_session_export.go
@@ -0,0 +1,258 @@
+package stage
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+ "syscall"
+ "time"
+
+ "git.a-wan.net/alan/pipelines/internal/opencode"
+ "git.a-wan.net/alan/pipelines/internal/protocol"
+)
+
+// exportPiSession reads only a settled, server-owned Pi session. os.Root confines
+// all opens, including during renames; explicit lstat checks additionally reject
+// even in-root symlinks. No CLI, agent, interrupt or recovery is invoked here.
+func exportPiSession(ctx context.Context, request SessionExportRequest) (opencode.ExportedSession, error) {
+ session := opencode.ExportedSession{ID: request.SessionID, Backend: "pi", Attempts: 1}
+ if err := ctx.Err(); err != nil {
+ return session, err
+ }
+ fail := func() (opencode.ExportedSession, error) {
+ return session, fmt.Errorf("Pi native session unavailable: invalid, active or unsettled retained evidence")
+ }
+ cache, err := os.UserCacheDir()
+ if err != nil || request.SessionID == "" || !filepath.IsAbs(request.Reference) || filepath.Clean(request.Reference) != request.Reference {
+ return fail()
+ }
+ base := filepath.Join(cache, "pipelines", "pi-sessions")
+ if filepath.Dir(request.Reference) != base || !strings.HasPrefix(filepath.Base(request.Reference), "stage-") {
+ return fail()
+ }
+ // The OS cache itself can have platform aliases (/var on macOS). From
+ // that trusted anchor onward, reject symlinks, including parent directories.
+ cacheRoot, err := os.OpenRoot(cache)
+ if err != nil {
+ return fail()
+ }
+ defer cacheRoot.Close()
+ rel, err := filepath.Rel(cache, request.Reference)
+ if err != nil {
+ return fail()
+ }
+ components := strings.Split(rel, string(filepath.Separator))
+ for i := range components {
+ info, err := cacheRoot.Lstat(filepath.Join(components[:i+1]...))
+ if err != nil || !info.IsDir() || !piOwned(info) || info.Mode().Perm()&0022 != 0 {
+ return fail()
+ }
+ }
+ info, err := cacheRoot.Lstat(rel)
+ if err != nil || info.Mode().Perm()&0077 != 0 {
+ return fail()
+ }
+ root, err := cacheRoot.OpenRoot(rel)
+ if err != nil {
+ return fail()
+ }
+ defer root.Close()
+ openedInfo, err := root.Stat(".")
+ if err != nil || !os.SameFile(info, openedInfo) {
+ return fail()
+ }
+ read := func(name string, limit int64) ([]byte, error) {
+ f, err := piOpenEvidence(root, name)
+ if err != nil {
+ return nil, err
+ }
+ defer f.Close()
+ data, err := io.ReadAll(io.LimitReader(f, limit+1))
+ if len(data) > int(limit) {
+ return nil, fmt.Errorf("oversized Pi control file")
+ }
+ return data, err
+ }
+ ownerData, err := read("owner.json", 16<<10)
+ var owner struct {
+ PID int `json:"pid"`
+ SessionID string `json:"session_id"`
+ SessionFile string `json:"session_file"`
+ }
+ if err != nil || json.Unmarshal(ownerData, &owner) != nil || owner.SessionID != request.SessionID || owner.PID <= 1 {
+ return fail()
+ }
+ quiet, err := read("quiescent", 32)
+ if err != nil || string(quiet) != "quiescent" || !errors.Is(syscall.Kill(owner.PID, 0), syscall.ESRCH) || !errors.Is(syscall.Kill(-owner.PID, 0), syscall.ESRCH) {
+ return fail()
+ }
+ if !filepath.IsAbs(owner.SessionFile) || filepath.Clean(owner.SessionFile) != owner.SessionFile || filepath.Ext(owner.SessionFile) != ".jsonl" {
+ return fail()
+ }
+ name, err := filepath.Rel(request.Reference, owner.SessionFile)
+ if err != nil || !filepath.IsLocal(name) {
+ return fail()
+ }
+ f, err := piOpenEvidence(root, name)
+ if err != nil {
+ return fail()
+ }
+ defer f.Close()
+ data, err := io.ReadAll(io.LimitReader(f, SessionExportSourceLimit+1))
+ if err != nil {
+ return fail()
+ }
+ session.Truncated = len(data) > SessionExportSourceLimit
+ if session.Truncated {
+ data = data[:SessionExportSourceLimit]
+ // A cut JSONL record is never fabricated or partially decoded.
+ if i := bytes.LastIndexByte(data, '\n'); i >= 0 {
+ data = data[:i+1]
+ } else {
+ data = nil
+ }
+ }
+ lines := bytes.Split(bytes.TrimSpace(data), []byte{'\n'})
+ var header struct {
+ Type, ID string
+ Version int
+ }
+ if len(lines) == 0 || json.Unmarshal(lines[0], &header) != nil || header.Type != "session" || header.ID != owner.SessionID || header.Version != 3 {
+ return fail()
+ }
+ // State-only entries are retained alongside the next actual message, not
+ // counted as invented conversation turns. Trailing entries follow the last.
+ pending := []opencode.ExportedPart{
+ {Type: "pi_native_header", Raw: append(json.RawMessage(nil), lines[0]...)},
+ {Type: "pi_native_owner", Raw: append(json.RawMessage(nil), ownerData...)},
+ }
+ for _, line := range lines[1:] {
+ if err := ctx.Err(); err != nil {
+ return session, err
+ }
+ if len(bytes.TrimSpace(line)) == 0 {
+ continue
+ }
+ var entry struct {
+ Type, ID, Timestamp string
+ Message json.RawMessage
+ }
+ if json.Unmarshal(line, &entry) != nil || entry.Type == "" || entry.Type == "session" {
+ return fail()
+ }
+ if entry.Type != "message" {
+ pending = append(pending, opencode.ExportedPart{Type: "pi_native_entry", Raw: append(json.RawMessage(nil), line...)})
+ continue
+ }
+ m := opencode.ExportedMessage{ID: entry.ID, Parts: pending}
+ pending = nil
+ if stamp, err := time.Parse(time.RFC3339Nano, entry.Timestamp); err == nil {
+ m.CreatedAt = stamp.UnixMilli()
+ }
+ if entry.Type == "message" {
+ var native struct {
+ Role, Model, Provider, ToolCallID, ToolName, ErrorMessage string
+ IsError bool
+ Content json.RawMessage
+ }
+ if json.Unmarshal(entry.Message, &native) != nil || native.Role == "" {
+ return fail()
+ }
+ m.Role, m.Model, m.Agent = native.Role, native.Model, native.Provider
+ var text string
+ if len(native.Content) == 0 {
+ // Native extension/bashExecution messages can use fields other
+ // than content; the complete entry below is their evidence.
+ } else if json.Unmarshal(native.Content, &text) == nil {
+ m.Parts = append(m.Parts, opencode.ExportedPart{Type: protocol.ChatPartText, Text: text})
+ } else {
+ var parts []json.RawMessage
+ if json.Unmarshal(native.Content, &parts) != nil {
+ return fail()
+ }
+ for _, raw := range parts {
+ var p struct {
+ Type, Text, Thinking, ID, Name string
+ Arguments json.RawMessage
+ }
+ if json.Unmarshal(raw, &p) != nil {
+ return fail()
+ }
+ part := opencode.ExportedPart{Type: p.Type, Text: p.Text, Raw: raw}
+ switch p.Type {
+ case "thinking":
+ part.Type, part.Text = protocol.ChatPartReasoning, p.Thinking
+ case "toolCall":
+ part.Type, part.ID, part.Name = protocol.ChatPartTool, p.ID, p.Name
+ part.State = &protocol.ChatToolState{Input: p.Arguments}
+ }
+ m.Parts = append(m.Parts, part)
+ }
+ }
+ if native.ErrorMessage != "" {
+ data, _ := json.Marshal(native.ErrorMessage)
+ m.Parts = append(m.Parts, opencode.ExportedPart{Type: "error", Raw: data})
+ }
+ if native.Role == "toolResult" {
+ status := "completed"
+ if native.IsError {
+ status = "error"
+ }
+ // The result remains its own real native turn, not spliced into
+ // an earlier call (which can be on a different session branch).
+ m.Parts = append(m.Parts, opencode.ExportedPart{Type: protocol.ChatPartTool,
+ ID: native.ToolCallID, Name: native.ToolName, State: &protocol.ChatToolState{Status: status}})
+ }
+ }
+ // Keep the actual entry (including toolResult isError, toolCallId,
+ // stopReason, unknown content and branch/compaction records) verbatim.
+ // This is native evidence, not a synthetic assistant placeholder.
+ m.Parts = append(m.Parts, opencode.ExportedPart{Type: "pi_native_entry", Raw: append(json.RawMessage(nil), line...)})
+ session.Messages = append(session.Messages, m)
+ }
+ if len(session.Messages) == 0 {
+ return session, opencode.ErrEmptySessionExport
+ }
+ last := &session.Messages[len(session.Messages)-1]
+ last.Parts = append(last.Parts, pending...)
+ return session, nil
+}
+
+func piOwned(info os.FileInfo) bool {
+ stat, ok := info.Sys().(*syscall.Stat_t)
+ return ok && stat.Uid == uint32(os.Geteuid())
+}
+
+func piOpenEvidence(root *os.Root, name string) (*os.File, error) {
+ if !filepath.IsLocal(name) {
+ return nil, fmt.Errorf("nonlocal Pi evidence")
+ }
+ parts := strings.Split(name, string(filepath.Separator))
+ var checked os.FileInfo
+ for i := range parts {
+ info, err := root.Lstat(filepath.Join(parts[:i+1]...))
+ if err != nil {
+ return nil, err
+ }
+ if info.Mode()&os.ModeSymlink != 0 || !piOwned(info) || info.Mode().Perm()&0022 != 0 || (i < len(parts)-1 && !info.IsDir()) || (i == len(parts)-1 && (!info.Mode().IsRegular() || info.Sys().(*syscall.Stat_t).Nlink != 1)) {
+ return nil, fmt.Errorf("unsafe Pi evidence")
+ }
+ checked = info
+ }
+ f, err := root.Open(name)
+ if err != nil {
+ return nil, err
+ }
+ info, err := f.Stat()
+ if err != nil || !os.SameFile(checked, info) || !info.Mode().IsRegular() || !piOwned(info) || info.Mode().Perm()&0022 != 0 || info.Sys().(*syscall.Stat_t).Nlink != 1 {
+ f.Close()
+ return nil, fmt.Errorf("unsafe Pi evidence")
+ }
+ return f, nil
+}
diff --git a/internal/stage/pi_session_export_test.go b/internal/stage/pi_session_export_test.go
new file mode 100644
index 00000000..3400b62a
--- /dev/null
+++ b/internal/stage/pi_session_export_test.go
@@ -0,0 +1,273 @@
+package stage
+
+import (
+ "context"
+ "encoding/json"
+ "os"
+ "path/filepath"
+ "strings"
+ "syscall"
+ "testing"
+)
+
+const piFixtureID = "b59a48a7-47bf-483f-9eac-78894d015648"
+
+// Fixture follows @earendil-works/pi-coding-agent 1.3.0's v3 FileEntry /
+// SessionMessageEntry and pi-ai Message types. Tests never execute Pi.
+func piExportFixture(t *testing.T) (SessionExportRequest, string) {
+ t.Helper()
+ home := t.TempDir()
+ t.Setenv("HOME", home)
+ t.Setenv("XDG_CACHE_HOME", filepath.Join(home, "cache"))
+ cache, err := os.UserCacheDir()
+ if err != nil {
+ t.Fatal(err)
+ }
+ ref := filepath.Join(cache, "pipelines", "pi-sessions", "stage-test")
+ if err := os.MkdirAll(ref, 0700); err != nil {
+ t.Fatal(err)
+ }
+ data, err := os.ReadFile("testdata/pi-session.jsonl")
+ if err != nil {
+ t.Fatal(err)
+ }
+ file := filepath.Join(ref, "2026-10-20T10-00-00_"+piFixtureID+".jsonl")
+ if err := os.WriteFile(file, data, 0644); err != nil {
+ t.Fatal(err)
+ }
+ // Use a confirmed nonexistent PID; neither the PID nor its process group
+ // is signalled or started by the exporter.
+ pid := 1 << 30
+ if syscall.Kill(pid, 0) != syscall.ESRCH || syscall.Kill(-pid, 0) != syscall.ESRCH {
+ t.Fatal("test PID unexpectedly exists")
+ }
+ owner, _ := json.Marshal(map[string]any{"pid": pid, "session_id": piFixtureID, "session_file": file})
+ for name, content := range map[string][]byte{"owner.json": owner, "quiescent": []byte("quiescent")} {
+ if err := os.WriteFile(filepath.Join(ref, name), content, 0600); err != nil {
+ t.Fatal(err)
+ }
+ }
+ return SessionExportRequest{Backend: "pi", SessionID: piFixtureID, Reference: ref, ArtifactsDir: t.TempDir(), RunID: 7, Sequence: 2, Stage: "verify"}, file
+}
+
+func TestPiSessionExportNativeEvidence(t *testing.T) {
+ req, file := piExportFixture(t)
+ t.Setenv("PIPELINES_OPENCODE", filepath.Join(t.TempDir(), "must-not-execute"))
+ result, err := ExportSession(context.Background(), req)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result.HTML != SessionHTMLFile || result.Messages != 4 || result.Attempts != 1 || result.Truncated || result.Source != "native_export" {
+ t.Fatalf("result: %+v", result)
+ }
+ data, err := os.ReadFile(filepath.Join(req.ArtifactsDir, result.HTML))
+ if err != nil {
+ t.Fatal(err)
+ }
+ html := string(data)
+ for _, want := range []string{piFixtureID, "pi_native_jsonl", req.Reference, filepath.Base(file), "pi_native_header", "user0001", "toolResult", "call_001", "tool: bash (error)", "cat missing.txt", "Need actual tool evidence <private>", "No such file <failure>", "isError":true", "The file is missing & the tool failed.", "provider failed <upstream>", "opaque-signature", "model_change"} {
+ if !strings.Contains(html, want) {
+ t.Errorf("missing %q", want)
+ }
+ }
+ if strings.Contains(html, " & report","timestamp":1792490401000}}
+{"type":"message","id":"assist01","parentId":"user0001","timestamp":"2026-10-20T10:00:02.000Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"Need actual tool evidence ","thinkingSignature":"opaque-signature"},{"type":"toolCall","id":"call_001","name":"bash","arguments":{"command":"cat missing.txt"}}],"api":"anthropic-messages","provider":"anthropic","model":"claude-sonnet-4-6","usage":{"input":10,"output":8,"cacheRead":0,"cacheWrite":0,"totalTokens":18,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0,"total":0}},"stopReason":"toolUse","timestamp":1792490402000}}
+{"type":"message","id":"result01","parentId":"assist01","timestamp":"2026-10-20T10:00:03.000Z","message":{"role":"toolResult","toolCallId":"call_001","toolName":"bash","content":[{"type":"text","text":"cat: missing.txt: No such file "}],"details":{"exitCode":1},"isError":true,"timestamp":1792490403000}}
+{"type":"message","id":"assist02","parentId":"result01","timestamp":"2026-10-20T10:00:04.000Z","message":{"role":"assistant","content":[{"type":"text","text":"The file is missing & the tool failed."}],"api":"anthropic-messages","provider":"anthropic","model":"claude-sonnet-4-6","stopReason":"error","errorMessage":"provider failed ","timestamp":1792490404000}}