Fix scenario card merge apply

Author: rschardosin

docs/architecture/memory.md

@@ -197,7 +197,7 @@ Implementation details:
 
 - `pkg/memory/scenario_card.go` owns rendering, parsing, draft generation, merge, upsert, and retrieval filtering.
 - `pkg/memory/scenario_identity.go` owns deterministic extraction, corpus statistics, pair scoring, and conservative candidate choice.
-- `MemoryMerger.SaveOrMerge` drafts/upserts a scenario card for platform memory saves and fails closed if the card cannot be saved. It must not fall back to raw-memory insertion because that would reintroduce scattered notes.
+- `MemoryMerger.SaveOrMerge` drafts/upserts a scenario card for platform memory saves and fails closed if the card cannot be saved. It must not fall back to raw-memory insertion because that would reintroduce scattered notes. Post-turn reflector saves created from a trace with successful non-memory/non-knowledge tool calls are marked `verified`; saves without execution evidence remain `draft` until a later successful run confirms them.
 - Promotion is upsert-based. Personal → team and team → org promotion draft a scenario card in the target scope and merge it with any existing card that resolves to the same scenario; after a successful upsert, the source raw memory is deleted.
 - Retrieval asks the underlying search for extra candidates, runs `memory.FilterPreferredScenarioResults`, prefers scenario cards, suppresses any transitional raw memories that are explicitly listed as `source_memory_ids`, and de-duplicates equivalent scenario cards as a safety net.
 
@@ -214,7 +214,7 @@ Memory Health returns reviewable, actionable recommendations, not automatic writ
 - clean up raw source memories that are already represented by an existing scenario card
 - merge duplicate scenario cards that deterministic identity resolution considers the same operational scenario
 
-Each recommendation contains the proposed card, target scope, source memory IDs, and the diagnostic flags that explain why it was suggested. Duplicate-card recommendations also include `duplicate_card_ids`, `resolver_signals`, and a `match_score`; applying one first upserts the merged card and then deletes only those explicit duplicate scenario-card rows. Applying any recommendation uses the same scenario-card upsert endpoint as manual consolidation; after the card is saved or merged, incorporated raw source memories are deleted. Cleanup recommendations re-save the existing card metadata and delete the still-visible raw source rows. If the proposed card contains only the placeholder recipe, the raw inputs are discarded and no placeholder card is saved.
+Each recommendation contains the proposed card, target scope, source memory IDs, and the diagnostic flags that explain why it was suggested. Duplicate-card recommendations also include `duplicate_card_ids`, `resolver_signals`, and a `match_score`; applying one saves the merged content in the target scope, preserves any existing non-duplicate card for the same resolved scenario, and then deletes only the explicit duplicate scenario-card rows. Applying any recommendation uses the same scenario-card upsert endpoint as manual consolidation; after the card is saved or merged, incorporated raw source memories are deleted. Cleanup recommendations re-save the existing card metadata and delete the still-visible raw source rows. If the proposed card contains only the placeholder recipe, the raw inputs are discarded and no placeholder card is saved.
 
 `GET /api/memories/map` remains available as the advanced diagnostic report behind the Memory Health UI. It groups likely related memory chunks by a canonical topic key and flags conditions that make memory feel scattered or unsafe:
 

docs/website/docs/agent/memory.md

@@ -109,5 +109,6 @@ memory:
 - Use categories for organization (the agent does this automatically)
 - In team deployments, publish useful memories to your team via Studio so colleagues benefit
 - The agent automatically searches memory before responding — no manual retrieval needed
+- In platform mode, durable operational knowledge is organized into scenario cards. Successful trace-backed recipes can be marked verified; unsupported notes remain draft until a later successful run confirms them.
 
 See [Sessions](./sessions.md) for how session history differs from memory, and [Three-Tier Memory](../platform/three-tier-memory.md) for the full multi-tier system.

docs/website/docs/platform/three-tier-memory.md

@@ -57,7 +57,7 @@ Personal  ──publish──▶  Team  ──promote──▶  Org
 1. **Personal → Team**: any team member can publish a memory entry to their team via Studio. This makes it searchable by all team members.
 2. **Team → Org**: a team admin or org admin promotes team knowledge to org level via Studio, making it available to every team in the organization.
 
-The agent can also save knowledge directly during conversations using the `memory_save` tool. The tier is determined by the current context.
+The agent can also save knowledge directly during conversations using the `memory_save` tool. The tier is determined by the current context. In platform mode, operational knowledge is stored as scenario cards when possible: trace-backed saves with successful external tool evidence are marked verified, while saves without execution evidence stay draft until a later successful run confirms them.
 
 Promotion now performs a scenario-card upsert. When possible, the selected memory is distilled into an efficient successful-path card in the target tier and merged with an existing card for the same scenario. Scenario matching uses deterministic identity anchors such as system, service family, resource type, operation, environment, credential, endpoint host family, API family, HTTP method, and URL path; the canonical key is treated as an alias, not the only identity. After the card is saved, the original raw source memory is deleted; if it cannot form a useful card, it is discarded rather than kept as durable memory.
 
@@ -68,7 +68,7 @@ Here is how knowledge compounds in practice:
 1. **Alice** debugs a tricky Kubernetes networking issue. The agent saves the resolution to her personal memory via `memory_save`.
 2. Alice publishes the resolution to the **Backend team** via Studio. Now when any backend engineer hits a similar issue, the agent surfaces Alice's solution.
 3. The team admin notices this resolution is relevant org-wide and **promotes it to org level** via Studio. If an org scenario card already exists for the same scenario identity, the new evidence is merged into that card instead of creating another duplicate memory.
-4. If two cards were already created with different labels for the same scenario, **Memory Health** can recommend a duplicate-card merge, show the resolver signals, save the merged card, and delete only the explicit duplicate card rows.
+4. If two cards were already created with different labels for the same scenario, **Memory Health** can recommend a duplicate-card merge, show the resolver signals, save the merged card into the target tier, preserve any existing non-duplicate card for that resolved scenario, and delete only the explicit duplicate card rows.
 5. **Dave** on the Frontend team later encounters the same networking issue. The agent finds the org-level scenario card and guides him through the efficient path — even though Dave never interacted with Alice.
 
 Each step is explicit. Knowledge does not leak upward automatically.

pkg/agent/memory_merge.go

@@ -30,6 +30,10 @@ type MergeResult struct {
 //
 // Returns the merge result indicating what action was taken.
 func (mm *MemoryMerger) SaveOrMerge(ctx context.Context, memStore store.MemoryStore, entry store.MemoryEntry) (MergeResult, error) {
+	return mm.SaveOrMergeWithStatus(ctx, memStore, entry, "")
+}
+
+func (mm *MemoryMerger) SaveOrMergeWithStatus(ctx context.Context, memStore store.MemoryStore, entry store.MemoryEntry, status string) (MergeResult, error) {
 	if memStore == nil {
 		return MergeResult{}, fmt.Errorf("memory store is nil")
 	}
@@ -42,6 +46,12 @@ func (mm *MemoryMerger) SaveOrMerge(ctx context.Context, memStore store.MemorySt
 	} else {
 		card = mem.DraftScenarioCardFromMemoryEntry("team", entry)
 	}
+	if status != "" {
+		card.Status = status
+		if status == mem.ScenarioCardStatusVerified && card.Confidence < 0.8 {
+			card.Confidence = 0.8
+		}
+	}
 	if !mem.HasUsableScenarioRecipe(card) {
 		return MergeResult{Action: "discarded"}, nil
 	}

pkg/agent/memory_merge_test.go

@@ -3,8 +3,10 @@ package agent
 import (
 	"context"
 	"errors"
+	"strings"
 	"testing"
 
+	mem "github.com/SAP/astonish/pkg/memory"
 	"github.com/SAP/astonish/pkg/store"
 )
 
@@ -43,9 +45,56 @@ func TestMemoryMergerDiscardsUncardableMemory(t *testing.T) {
 	}
 }
 
+func TestMemoryMergerCanMarkTraceBackedScenarioCardsVerified(t *testing.T) {
+	memStore := &failingScenarioUpsertStore{}
+	merger := &MemoryMerger{}
+
+	result, err := merger.SaveOrMergeWithStatus(context.Background(), memStore, store.MemoryEntry{
+		Content:  "Use the noVNC ticket endpoint, then open the websocket with the returned ticket.",
+		Category: "proxmox-console-access",
+	}, mem.ScenarioCardStatusVerified)
+	if err != nil {
+		t.Fatalf("SaveOrMergeWithStatus returned error: %v", err)
+	}
+	if result.Action != "created" {
+		t.Fatalf("Action = %q, want created", result.Action)
+	}
+	if !strings.Contains(memStore.added.Content, "status: verified") {
+		t.Fatalf("saved card was not marked verified: %s", memStore.added.Content)
+	}
+}
+
+func TestPlatformReflectorMarksExistingSessionCardsVerified(t *testing.T) {
+	card := mem.ScenarioCard{
+		CanonicalKey:      "proxmox-console-access",
+		Title:             "Proxmox Console Access",
+		RecommendedRecipe: []string{"Use the noVNC ticket endpoint."},
+		Status:            mem.ScenarioCardStatusDraft,
+	}
+	memStore := &failingScenarioUpsertStore{entries: map[string]store.MemorySearchResult{
+		"card-1": {
+			ID:        "card-1",
+			Snippet:   mem.RenderScenarioCard(card),
+			Category:  mem.ScenarioCardCategory,
+			SessionID: "session-1",
+		},
+	}}
+
+	(&PlatformReflector{}).markScenarioCardsVerifiedForSession(context.Background(), memStore, "session-1")
+	updated, ok := mem.ParseScenarioCard(memStore.entries["card-1"].Snippet)
+	if !ok {
+		t.Fatalf("updated memory is not a scenario card: %s", memStore.entries["card-1"].Snippet)
+	}
+	if updated.Status != mem.ScenarioCardStatusVerified {
+		t.Fatalf("card was not verified: %#v", updated)
+	}
+}
+
 type failingScenarioUpsertStore struct {
 	listErr   error
 	addCalled bool
+	added     store.MemoryEntry
+	entries   map[string]store.MemorySearchResult
 }
 
 func (f *failingScenarioUpsertStore) Search(context.Context, string, int, float64) ([]store.MemorySearchResult, error) {
@@ -56,16 +105,29 @@ func (f *failingScenarioUpsertStore) SearchByCategory(context.Context, string, i
 	return nil, nil
 }
 
-func (f *failingScenarioUpsertStore) Add(context.Context, store.MemoryEntry) error {
+func (f *failingScenarioUpsertStore) Add(_ context.Context, entry store.MemoryEntry) error {
 	f.addCalled = true
+	f.added = entry
 	return nil
 }
 
-func (f *failingScenarioUpsertStore) Get(context.Context, string) (*store.MemorySearchResult, error) {
-	return nil, nil
+func (f *failingScenarioUpsertStore) Get(_ context.Context, id string) (*store.MemorySearchResult, error) {
+	entry, ok := f.entries[id]
+	if !ok {
+		return nil, nil
+	}
+	return &entry, nil
 }
 
-func (f *failingScenarioUpsertStore) Update(context.Context, string, string, string) error {
+func (f *failingScenarioUpsertStore) Update(_ context.Context, id, content, category string) error {
+	if f.entries == nil {
+		f.entries = make(map[string]store.MemorySearchResult)
+	}
+	entry := f.entries[id]
+	entry.ID = id
+	entry.Snippet = content
+	entry.Category = category
+	f.entries[id] = entry
 	return nil
 }
 
@@ -75,8 +137,14 @@ func (f *failingScenarioUpsertStore) List(context.Context, string, int, int) ([]
 	return nil, f.listErr
 }
 
-func (f *failingScenarioUpsertStore) ListBySession(context.Context, string) ([]store.MemorySearchResult, error) {
-	return nil, nil
+func (f *failingScenarioUpsertStore) ListBySession(_ context.Context, sessionID string) ([]store.MemorySearchResult, error) {
+	var out []store.MemorySearchResult
+	for _, entry := range f.entries {
+		if entry.SessionID == sessionID {
+			out = append(out, entry)
+		}
+	}
+	return out, nil
 }
 
 func (f *failingScenarioUpsertStore) Count() int { return 0 }