internal/memory/decisions.go (1)

33-49: ⚠️ Potential issue | 🟠 Major

Make the decision insert and memory insert atomic.

The new error check is better, but these writes still happen outside a transaction. If the memory INSERT fails, this returns an error after the decision row has already been committed, so retries can create duplicate decisions while the memory table stays out of sync.

🧩 Wrap both writes in one transaction

 func (s *Store) RecordDecision(ctx context.Context, projectID, title, decision, rationale string, alternatives, tags []string) (string, error) {
 	s.mu.Lock()
 	defer s.mu.Unlock()

 	altJSON, _ := json.Marshal(alternatives)
 	tagJSON, _ := json.Marshal(tags)

+	tx, err := s.db.BeginTx(ctx, nil)
+	if err != nil {
+		return "", fmt.Errorf("begin decision tx: %w", err)
+	}
+	defer tx.Rollback()
+
 	var id string
-	err := s.db.QueryRowContext(ctx, `
+	err = tx.QueryRowContext(ctx, `
 		INSERT INTO decisions (project_id, title, decision, alternatives, rationale, tags)
 		VALUES (?, ?, ?, ?, ?, ?)
 		RETURNING id
 	`, projectID, title, decision, string(altJSON), rationale, string(tagJSON)).Scan(&id)
 	if err != nil {
 		return "", fmt.Errorf("record decision: %w", err)
 	}

 	// Also save as a memory so it shows up in search and prompt context.
 	content := fmt.Sprintf("%s: %s. Rationale: %s", title, decision, rationale)
-	if _, err := s.db.ExecContext(ctx, `
+	if _, err := tx.ExecContext(ctx, `
 		INSERT INTO memories (project_id, category, content, source, importance, tags)
 		VALUES (?, 'decision', ?, 'decision_log', 0.9, ?)
 	`, projectID, content, string(tagJSON)); err != nil {
-		return id, fmt.Errorf("record decision memory: %w", err)
+		return "", fmt.Errorf("record decision memory: %w", err)
+	}
+	if err := tx.Commit(); err != nil {
+		return "", fmt.Errorf("commit decision tx: %w", err)
 	}

 	if s.onSave != nil {
 		s.onSave(projectID)
 	}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/memory/decisions.go` around lines 33 - 49, Wrap the decision INSERT
and the subsequent memory INSERT in a single DB transaction so both succeed or
both roll back: start a transaction with s.db.BeginTx(ctx, nil), perform the
decisions INSERT via tx.QueryRowContext(...).Scan(&id) (using projectID, title,
decision, string(altJSON), rationale, string(tagJSON)), then perform the
memories INSERT via tx.ExecContext(...) (using projectID, content,
string(tagJSON)); on any error call tx.Rollback() and return the wrapped error,
and on success call tx.Commit() before returning id. Ensure you replace
s.db.QueryRowContext/ExecContext with tx.QueryRowContext/tx.ExecContext and
still return the same error messages (e.g., "record decision: %w" and "record
decision memory: %w").

internal/memory/store.go (1)

505-533: ⚠️ Potential issue | 🟠 Major

Don't rebuild exchanges from a flattened message window.

Because the subquery drops conversation_id, the loop can only pair by adjacency. That breaks if conversations overlap, and it also under-fills limit when the newest window starts with an unanswered user turn. Those bad pairs flow straight into internal/reflection/engine.go:74-99 and internal/reflection/prompt.go:35-52. Keep conversation identity through the query and apply the final limit after complete user→assistant pairs are formed.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@internal/memory/store.go` around lines 505 - 533, The current SQL drops
conversation_id which forces pairing by adjacency; change the query to SELECT
conversation_id, role, content, created_at (so you retain conversation identity)
and then in the rows loop use a map keyed by conversation_id to build
per-conversation [2]string user→assistant pairs (use created_at to order within
each conversation), collect all completed pairs across conversations, sort them
by their assistant message created_at (or user created_at depending on desired
semantics) and only then apply the final limit before returning; update the
variables and logic around pairs/current to reference conversation_id and ensure
empty user starts are ignored so you don’t under-fill results consumed by
internal/reflection/engine.go and internal/reflection/prompt.go.