diff --git a/agent/chat.go b/agent/chat.go index ea750af..d067cb4 100644 --- a/agent/chat.go +++ b/agent/chat.go @@ -169,9 +169,12 @@ func (c *ChatAgent) Chat(ctx context.Context, agentKey, sessionID, message strin if c.guard != nil { opts.Hooks = c.guard.Hooks() } + // The session id is the provider-side identity (session header, usage metering) + // with or without persistence; Norma only puts it on ctx when it writes a transcript. + opts.SessionID = sessionID + ctx = transcript.WithSessionID(ctx, opts.SessionID) if c.tx != nil { // persist raw human↔AI conversation; one accumulating file per thread opts.Transcript = c.tx - opts.SessionID = sessionID } // experimental feature: when enabled, noa takes over context compression (archive centralized under /noa/, persistent). enableNoa(&opts, c.noaEnabledFn, c.workDir, "chat-"+sessionID, noaWarn("chat-"+sessionID)) @@ -180,8 +183,11 @@ func (c *ChatAgent) Chat(ctx context.Context, agentKey, sessionID, message strin defer s.Close() // reload prior conversation so the agent has context across turns (each Chat is // a fresh session). First turn: no file yet → Resume loads nothing and proceeds. + // A corrupt or unreadable transcript stops the turn before any model or tool call. if c.tx != nil { - _ = s.Resume(sessionID) + if err := resumeSession(s, opts.SessionID); err != nil { + return "", err + } } // re-unlock skill-gated MCPs from prior Skill() calls in the reloaded history so // revealed tools stay callable across the fresh session. diff --git a/agent/mainagent.go b/agent/mainagent.go index 3f55182..3b8345b 100644 --- a/agent/mainagent.go +++ b/agent/mainagent.go @@ -169,14 +169,17 @@ func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db. if hooks != nil { // typed-nil guard: only set when concrete (avoids harness panic) opts.Hooks = hooks } + // Segment 0 keeps the legacy "exp%d-main" name so existing transcripts still + // load; each new session (seg>=1) gets its own file for a clean context. The id + // is the provider-side identity (session header, usage metering) with or without + // persistence; Norma only puts it on ctx when it writes a transcript. + opts.SessionID = fmt.Sprintf("exp%d-main", ts.ID()) + if mainSeg > 0 { + opts.SessionID = fmt.Sprintf("exp%d-main-s%d", ts.ID(), mainSeg) + } + ctx = transcript.WithSessionID(ctx, opts.SessionID) if m.tx != nil { // persist raw human↔AI conversation; one accumulating file per segment opts.Transcript = m.tx - // Segment 0 keeps the legacy "exp%d-main" name so existing transcripts still - // load; each new session (seg>=1) gets its own file for a clean context. - opts.SessionID = fmt.Sprintf("exp%d-main", ts.ID()) - if mainSeg > 0 { - opts.SessionID = fmt.Sprintf("exp%d-main-s%d", ts.ID(), mainSeg) - } } // experimental feature: when enabled, noa takes over context compression (archive centralized under /noa/, persistent). // the session id follows the same rule as the transcript (segment-aware), keeping archive and resume aligned. @@ -191,8 +194,11 @@ func (m *MainAgent) Chat(ctx context.Context, taskID int64, mainSeg int, as *db. // reload the prior conversation from the transcript so the agent has context // across turns (each Chat is a fresh session; without this it can't see earlier // messages). First turn: no file yet → Resume loads nothing and proceeds. + // A corrupt or unreadable transcript stops the turn before any model or tool call. if m.tx != nil { - _ = s.Resume(opts.SessionID) + if err := resumeSession(s, opts.SessionID); err != nil { + return "", err + } } // C2: this session is fresh each turn; re-unlock skill-gated MCPs from prior // Skill() calls in the reloaded history so revealed tools stay callable. diff --git a/agent/planner.go b/agent/planner.go index 9e3c34f..5558244 100644 --- a/agent/planner.go +++ b/agent/planner.go @@ -567,9 +567,12 @@ func (p *Planner) Plan(ctx context.Context, taskID int64, as *db.AssetStore, ts if hooks != nil { // typed-nil guard: only set when concrete (avoids harness panic) opts.Hooks = hooks } + // The session id is the provider-side identity (session header, usage metering) + // with or without persistence; Norma only puts it on ctx when it writes a transcript. + opts.SessionID = fmt.Sprintf("exp%d-planner", ts.ID()) + ctx = transcript.WithSessionID(ctx, opts.SessionID) if p.tx != nil { // persist raw LLM conversation; one accumulating file per task's planner opts.Transcript = p.tx - opts.SessionID = fmt.Sprintf("exp%d-planner", ts.ID()) } // Experimental: when on, noa takes over context compression (archives persist under /noa/). noaSession := fmt.Sprintf("exp%d-planner", ts.ID()) diff --git a/agent/session.go b/agent/session.go new file mode 100644 index 0000000..616810e --- /dev/null +++ b/agent/session.go @@ -0,0 +1,19 @@ +package agent + +import ( + "fmt" + + "github.com/Autumn-27/norma/agentcore" +) + +// resumeSession reloads the persisted conversation of session id into s. Norma's +// transcript.Store.Load treats a missing file as a fresh session (no records, no +// error); any other failure, such as a corrupt line or an unreadable path, is +// returned so the caller stops before the first model or tool call instead of +// appending a new conversation to the damaged file. +func resumeSession(s *agentcore.Session, id string) error { + if err := s.Resume(id); err != nil { + return fmt.Errorf("restore Norma session %q: %w", id, err) + } + return nil +} diff --git a/agent/session_test.go b/agent/session_test.go new file mode 100644 index 0000000..ca3a686 --- /dev/null +++ b/agent/session_test.go @@ -0,0 +1,305 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "iter" + "os" + "path/filepath" + "strings" + "sync" + "testing" + + "github.com/Autumn-27/artex/db" + "github.com/Autumn-27/norma/llm" + "github.com/Autumn-27/norma/transcript" +) + +// sessionProbe is a provider that answers every call with one text turn and +// records the session id it saw on ctx plus the request messages. +type sessionProbe struct { + mu sync.Mutex + ids []string + msgs [][]llm.Message +} + +func (p *sessionProbe) Stream(ctx context.Context, req llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] { + p.mu.Lock() + p.ids = append(p.ids, transcript.SessionIDFrom(ctx)) + p.msgs = append(p.msgs, req.Messages) + p.mu.Unlock() + return func(yield func(llm.StreamEvent, error) bool) { + if yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "done"}, nil) { + yield(llm.StreamEvent{Type: llm.SEMessageDelta, StopReason: "end_turn"}, nil) + } + } +} + +func (p *sessionProbe) Complete(ctx context.Context, req llm.CompletionRequest) (llm.Message, string, llm.Usage, error) { + acc := llm.NewAccumulator() + for ev, err := range p.Stream(ctx, req) { + if err != nil { + return llm.Message{}, "", llm.Usage{}, err + } + acc.Add(ev) + } + return acc.Message(), acc.StopReason, acc.Usage, nil +} + +func (p *sessionProbe) seen() []string { + p.mu.Lock() + defer p.mu.Unlock() + return append([]string(nil), p.ids...) +} + +// jsonlFiles lists every .jsonl file under dir. +func jsonlFiles(t *testing.T, dir string) []string { + t.Helper() + var out []string + err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error { + if err != nil { + return err + } + if !d.IsDir() && strings.HasSuffix(path, ".jsonl") { + out = append(out, path) + } + return nil + }) + if err != nil { + t.Fatal(err) + } + return out +} + +// damageTranscript makes the main transcript of id corrupt (a non-JSON line) or +// unreadable (a directory). It returns the bytes a corrupt file must keep. +func damageTranscript(t *testing.T, store *transcript.Store, id string, unreadable bool) string { + t.Helper() + path := store.MainPath(id) + if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil { + t.Fatal(err) + } + if unreadable { + if err := os.Mkdir(path, 0o700); err != nil { + t.Fatal(err) + } + return "" + } + const original = "{corrupt transcript\n" + if err := os.WriteFile(path, []byte(original), 0o600); err != nil { + t.Fatal(err) + } + return original +} + +// assertTranscriptUntouched checks that a damaged transcript was neither +// rewritten nor appended to. +func assertTranscriptUntouched(t *testing.T, store *transcript.Store, id, original string, unreadable bool) { + t.Helper() + path := store.MainPath(id) + if unreadable { + entries, err := os.ReadDir(path) + if err != nil || len(entries) != 0 { + t.Fatalf("unreadable transcript changed: entries=%v err=%v", entries, err) + } + return + } + b, err := os.ReadFile(path) + if err != nil || string(b) != original { + t.Fatalf("damaged transcript changed: %q err=%v", b, err) + } +} + +func assertRestoreError(t *testing.T, err error, calls int) { + t.Helper() + if err == nil || !strings.Contains(err.Error(), "restore Norma session") || calls != 0 { + t.Fatalf("err=%v provider calls=%d", err, calls) + } +} + +var damageCases = []struct { + name string + unreadable bool +}{{"corrupt", false}, {"unreadable-directory", true}} + +func TestChatSessionIdentityWithoutTranscript(t *testing.T) { + p := &sessionProbe{} + workDir := t.TempDir() + c := NewChatAgent(p, "test-model", workDir, nil, 100000) + for range 2 { + if _, err := c.Chat(t.Context(), "assistant", "conv-stable", "hello", 1, 0, false, nil); err != nil { + t.Fatal(err) + } + } + if ids := p.seen(); len(ids) != 2 || ids[0] != "conv-stable" || ids[1] != "conv-stable" { + t.Fatalf("provider session ids: %v", ids) + } + if files := jsonlFiles(t, workDir); len(files) != 0 { + t.Fatalf("transcript written without persistence: %v", files) + } +} + +func TestChatMissingTranscriptStartsFresh(t *testing.T) { + store := transcript.NewStore(t.TempDir()) + p := &sessionProbe{} + c := NewChatAgent(p, "test-model", t.TempDir(), store, 100000) + if _, err := c.Chat(t.Context(), "assistant", "conv-new", "hello", 1, 0, false, nil); err != nil { + t.Fatal(err) + } + if ids := p.seen(); len(ids) != 1 || ids[0] != "conv-new" { + t.Fatalf("provider session ids: %v", ids) + } + recs, err := store.Load(store.MainPath("conv-new")) + if err != nil || len(recs) == 0 { + t.Fatalf("fresh transcript not written: %d records, err=%v", len(recs), err) + } +} + +func TestChatRefusesDamagedTranscript(t *testing.T) { + for _, tc := range damageCases { + t.Run(tc.name, func(t *testing.T) { + store := transcript.NewStore(t.TempDir()) + original := damageTranscript(t, store, "conv-broken", tc.unreadable) + p := &sessionProbe{} + c := NewChatAgent(p, "test-model", t.TempDir(), store, 100000) + _, err := c.Chat(t.Context(), "assistant", "conv-broken", "hello", 1, 0, false, nil) + assertRestoreError(t, err, len(p.seen())) + assertTranscriptUntouched(t, store, "conv-broken", original, tc.unreadable) + }) + } +} + +func TestChatResumesSignedThinkingHistory(t *testing.T) { + store := transcript.NewStore(t.TempDir()) + w := store.NewWriter("conv-signed", "") + w.RecordMessage(llm.UserText("earlier question"), llm.Usage{}) + w.RecordMessage(llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{ + {Type: llm.BlockThinking, Thinking: "reasoning", Signature: "signed"}, + {Type: llm.BlockRedactedThinking, Data: "opaque"}, + {Type: llm.BlockText, Text: "earlier answer"}, + }}, llm.Usage{}) + if err := w.Err(); err != nil { + t.Fatal(err) + } + p := &sessionProbe{} + c := NewChatAgent(p, "test-model", t.TempDir(), store, 100000) + if _, err := c.Chat(t.Context(), "assistant", "conv-signed", "next question", 1, 0, false, nil); err != nil { + t.Fatal(err) + } + p.mu.Lock() + defer p.mu.Unlock() + if len(p.msgs) != 1 { + t.Fatalf("provider calls: %d", len(p.msgs)) + } + var thinking, redacted bool + for _, m := range p.msgs[0] { + for _, b := range m.Content { + thinking = thinking || (b.Type == llm.BlockThinking && b.Thinking == "reasoning" && b.Signature == "signed") + redacted = redacted || (b.Type == llm.BlockRedactedThinking && b.Data == "opaque") + } + } + if !thinking || !redacted { + t.Fatalf("resumed history lost signed thinking=%v redacted=%v: %+v", thinking, redacted, p.msgs[0]) + } +} + +// sessionFixture is one exploration with one intent on the test database. +type sessionFixture struct { + expID int64 + intentID int64 + ts *db.ExplorationStore + intent *db.Node +} + +func newSessionFixture(t *testing.T) sessionFixture { + t.Helper() + d := testDB(t) + t.Cleanup(func() { _ = d.Close() }) + expID, err := d.CreateExploration("session identity probe", "keep the session id stable") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _, _ = d.Exec(`DELETE FROM explorations WHERE id=$1`, expID) }) + ts := d.Exploration(expID) + payload := map[string]any{"summary": "session probe"} + intentID, err := ts.AddNode("intent", payload, 0, "running", "planner", nil) + if err != nil { + t.Fatal(err) + } + raw, _ := json.Marshal(payload) + return sessionFixture{expID: expID, intentID: intentID, ts: ts, intent: &db.Node{ID: intentID, Payload: raw}} +} + +// run drives one agent kind once and returns the session id it should use. +func (f sessionFixture) run(t *testing.T, kind string, p *sessionProbe, tx *transcript.Store) (string, error) { + t.Helper() + workDir := t.TempDir() + switch kind { + case "worker": + _, _, err := NewWorker(p, "test-model", workDir, tx, 0, 3).Execute(t.Context(), "work#1", f.expID, nil, f.ts, f.intent, passHooks{}, nil, nil, nil) + return WorkerSessionID(f.expID, f.intentID), err + case "planner": + _, _, err := NewPlanner(p, "test-model", workDir, tx, 0, 3).Plan(t.Context(), f.expID, nil, f.ts, "probe goal", nil, passHooks{}, nil) + return fmt.Sprintf("exp%d-planner", f.expID), err + case "mainagent": + _, err := NewMainAgent(p, "test-model", workDir, tx, 0, 3).Chat(t.Context(), f.expID, 0, nil, f.ts, "probe goal", "status?", passHooks{}, nil, nil, nil, nil, nil) + return fmt.Sprintf("exp%d-main", f.expID), err + case "mainagent-seg": + _, err := NewMainAgent(p, "test-model", workDir, tx, 0, 3).Chat(t.Context(), f.expID, 2, nil, f.ts, "probe goal", "status?", passHooks{}, nil, nil, nil, nil, nil) + return fmt.Sprintf("exp%d-main-s2", f.expID), err + } + t.Fatalf("unknown agent kind %q", kind) + return "", nil +} + +func TestAgentSessionIdentityWithAndWithoutTranscript(t *testing.T) { + f := newSessionFixture(t) + for _, kind := range []string{"worker", "planner", "mainagent", "mainagent-seg"} { + t.Run(kind, func(t *testing.T) { + bare := &sessionProbe{} + want, err := f.run(t, kind, bare, nil) + if err != nil { + t.Fatal(err) + } + store := transcript.NewStore(t.TempDir()) + persisted := &sessionProbe{} + if _, err := f.run(t, kind, persisted, store); err != nil { + t.Fatal(err) + } + for _, ids := range [][]string{bare.seen(), persisted.seen()} { + if len(ids) == 0 { + t.Fatal("provider never called") + } + for _, id := range ids { + if id != want { + t.Fatalf("provider session ids %v, want %q", ids, want) + } + } + } + if recs, err := store.Load(store.MainPath(want)); err != nil || len(recs) == 0 { + t.Fatalf("transcript %q not written under the session id: %d records, err=%v", want, len(recs), err) + } + }) + } +} + +func TestAgentRefusesDamagedTranscript(t *testing.T) { + f := newSessionFixture(t) + for _, kind := range []string{"worker", "mainagent"} { + for _, tc := range damageCases { + t.Run(kind+"/"+tc.name, func(t *testing.T) { + store := transcript.NewStore(t.TempDir()) + id := WorkerSessionID(f.expID, f.intentID) + if kind == "mainagent" { + id = fmt.Sprintf("exp%d-main", f.expID) + } + original := damageTranscript(t, store, id, tc.unreadable) + p := &sessionProbe{} + _, err := f.run(t, kind, p, store) + assertRestoreError(t, err, len(p.seen())) + assertTranscriptUntouched(t, store, id, original, tc.unreadable) + }) + } + } +} diff --git a/agent/worker.go b/agent/worker.go index f1a4e49..b10cbeb 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -540,9 +540,12 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db. if hooks != nil { // typed-nil guard: only set when concrete (avoids harness panic) opts.Hooks = hooks } + // The session id is the provider-side identity (session header, usage metering) + // with or without persistence; Norma only puts it on ctx when it writes a transcript. + opts.SessionID = WorkerSessionID(ts.ID(), intent.ID) + ctx = transcript.WithSessionID(ctx, opts.SessionID) if w.tx != nil { // persist raw LLM conversation; one file per worked intent opts.Transcript = w.tx - opts.SessionID = WorkerSessionID(ts.ID(), intent.ID) } intentID := intent.ID emitWrap := func(r db.Activity) { @@ -574,7 +577,12 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db. // restarting from scratch. alreadyRecorded := false if w.tx != nil { - _ = s.Resume(opts.SessionID) + // A corrupt or unreadable transcript stops the run before any model or tool + // call. No terminal reason: the engine marks the intent blocked without the + // model_error reruns, which would only fail the same way again. + if err := resumeSession(s, opts.SessionID); err != nil { + return "", tsx.Writes(), err + } alreadyRecorded = requestID != "" && hasWorkerChatMessage(s.Messages(), requestID) if len(s.Messages()) > 0 && message == "" { seedUnlockFromHistory(s.Messages(), def.UnlockSkill)